diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
index f4ca09d3cb..81680080eb 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
@@ -8,8 +8,6 @@ System.CommandLine
     public System.Type ValueType { get; }
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
     public System.Object GetDefaultValue()
-    public ParseResult Parse(System.String commandLine)
-    public ParseResult Parse(System.String[] args)
     public System.String ToString()
   public class Argument<T> : Argument, IValueDescriptor<T>, System.CommandLine.Binding.IValueDescriptor
     .ctor()
@@ -56,44 +54,48 @@ System.CommandLine
     public System.Void Add(Symbol symbol)
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
     public System.Collections.Generic.IEnumerator<Symbol> GetEnumerator()
+    public ParseResult Parse(System.Collections.Generic.IReadOnlyList<System.String> args, CommandLineConfiguration configuration = null)
+    public ParseResult Parse(System.String commandLine, CommandLineConfiguration configuration = null)
   public static class CommandExtensions
     public static System.Int32 Invoke(this Command command, System.String[] args, IConsole console = null)
     public static System.Int32 Invoke(this Command command, System.String commandLine, IConsole console = null)
     public static System.Threading.Tasks.Task<System.Int32> InvokeAsync(this Command command, System.String[] args, IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
     public static System.Threading.Tasks.Task<System.Int32> InvokeAsync(this Command command, System.String commandLine, IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
-    public static ParseResult Parse(this Command command, System.String[] args)
-    public static ParseResult Parse(this Command command, System.String commandLine)
   public class CommandLineBuilder
-    .ctor(Command rootCommand = null)
+    .ctor(Command rootCommand)
     public Command Command { get; }
-    public System.CommandLine.Parsing.Parser Build()
-  public static class CommandLineBuilderExtensions
-    public static CommandLineBuilder AddMiddleware(this CommandLineBuilder builder, System.CommandLine.Invocation.InvocationMiddleware middleware, System.CommandLine.Invocation.MiddlewareOrder order = Default)
-    public static CommandLineBuilder AddMiddleware(this CommandLineBuilder builder, System.Action<System.CommandLine.Invocation.InvocationContext> onInvoke, System.CommandLine.Invocation.MiddlewareOrder order = Default)
-    public static CommandLineBuilder CancelOnProcessTermination(this CommandLineBuilder builder, System.Nullable<System.TimeSpan> timeout = null)
-    public static CommandLineBuilder EnableDirectives(this CommandLineBuilder builder, System.Boolean value = True)
-    public static CommandLineBuilder EnablePosixBundling(this CommandLineBuilder builder, System.Boolean value = True)
-    public static CommandLineBuilder RegisterWithDotnetSuggest(this CommandLineBuilder builder)
-    public static CommandLineBuilder UseDefaults(this CommandLineBuilder builder)
-    public static CommandLineBuilder UseEnvironmentVariableDirective(this CommandLineBuilder builder)
-    public static CommandLineBuilder UseExceptionHandler(this CommandLineBuilder builder, System.Action<System.Exception,System.CommandLine.Invocation.InvocationContext> onException = null, System.Nullable<System.Int32> errorExitCode = null)
-    public static CommandLineBuilder UseHelp(this CommandLineBuilder builder, System.Nullable<System.Int32> maxWidth = null)
-    public static CommandLineBuilder UseHelp(this CommandLineBuilder builder, System.String[] helpAliases)
-    public static CommandLineBuilder UseHelp(this CommandLineBuilder builder, System.Action<System.CommandLine.Help.HelpContext> customize, System.Nullable<System.Int32> maxWidth = null)
-    public static TBuilder UseHelpBuilder<TBuilder>(this TBuilder builder, System.Func<System.CommandLine.Binding.BindingContext,System.CommandLine.Help.HelpBuilder> getHelpBuilder)
-    public static CommandLineBuilder UseParseDirective(this CommandLineBuilder builder, System.Int32 errorExitCode = 1)
-    public static CommandLineBuilder UseParseErrorReporting(this CommandLineBuilder builder, System.Int32 errorExitCode = 1)
-    public static CommandLineBuilder UseSuggestDirective(this CommandLineBuilder builder)
-    public static CommandLineBuilder UseTokenReplacer(this CommandLineBuilder builder, System.CommandLine.Parsing.TryReplaceToken replaceToken)
-    public static CommandLineBuilder UseTypoCorrections(this CommandLineBuilder builder, System.Int32 maxLevenshteinDistance = 3)
-    public static CommandLineBuilder UseVersionOption(this CommandLineBuilder builder)
-    public static CommandLineBuilder UseVersionOption(this CommandLineBuilder builder, System.String[] aliases)
+    public CommandLineBuilder AddMiddleware(System.CommandLine.Invocation.InvocationMiddleware middleware, System.CommandLine.Invocation.MiddlewareOrder order = Default)
+    public CommandLineBuilder AddMiddleware(System.Action<System.CommandLine.Invocation.InvocationContext> onInvoke, System.CommandLine.Invocation.MiddlewareOrder order = Default)
+    public CommandLineConfiguration Build()
+    public CommandLineBuilder CancelOnProcessTermination(System.Nullable<System.TimeSpan> timeout = null)
+    public CommandLineBuilder EnableDirectives(System.Boolean value = True)
+    public CommandLineBuilder EnablePosixBundling(System.Boolean value = True)
+    public CommandLineBuilder RegisterWithDotnetSuggest()
+    public CommandLineBuilder UseDefaults()
+    public CommandLineBuilder UseEnvironmentVariableDirective()
+    public CommandLineBuilder UseExceptionHandler(System.Action<System.Exception,System.CommandLine.Invocation.InvocationContext> onException = null, System.Nullable<System.Int32> errorExitCode = null)
+    public CommandLineBuilder UseHelp(System.Nullable<System.Int32> maxWidth = null)
+    public CommandLineBuilder UseHelp(System.String[] helpAliases)
+    public CommandLineBuilder UseHelp(System.Action<System.CommandLine.Help.HelpContext> customize, System.Nullable<System.Int32> maxWidth = null)
+    public CommandLineBuilder UseHelpBuilder(System.Func<System.CommandLine.Binding.BindingContext,System.CommandLine.Help.HelpBuilder> getHelpBuilder)
+    public CommandLineBuilder UseParseDirective(System.Int32 errorExitCode = 1)
+    public CommandLineBuilder UseParseErrorReporting(System.Int32 errorExitCode = 1)
+    public CommandLineBuilder UseSuggestDirective()
+    public CommandLineBuilder UseTokenReplacer(System.CommandLine.Parsing.TryReplaceToken replaceToken)
+    public CommandLineBuilder UseTypoCorrections(System.Int32 maxLevenshteinDistance = 3)
+    public CommandLineBuilder UseVersionOption()
+    public CommandLineBuilder UseVersionOption(System.String[] aliases)
   public class CommandLineConfiguration
+    public static CommandLineBuilder CreateBuilder(Command rootCommand)
     .ctor(Command command, System.Boolean enablePosixBundling = True, System.Boolean enableDirectives = True, System.Boolean enableTokenReplacement = True, System.Collections.Generic.IReadOnlyList<System.CommandLine.Invocation.InvocationMiddleware> middlewarePipeline = null, System.Func<System.CommandLine.Binding.BindingContext,System.CommandLine.Help.HelpBuilder> helpBuilderFactory = null, System.CommandLine.Parsing.TryReplaceToken tokenReplacer = null)
     public System.Boolean EnableDirectives { get; }
     public System.Boolean EnablePosixBundling { get; }
     public System.Boolean EnableTokenReplacement { get; }
     public Command RootCommand { get; }
+    public System.Int32 Invoke(System.String commandLine, IConsole console = null)
+    public System.Int32 Invoke(System.String[] args, IConsole console = null)
+    public System.Threading.Tasks.Task<System.Int32> InvokeAsync(System.String commandLine, IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
+    public System.Threading.Tasks.Task<System.Int32> InvokeAsync(System.String[] args, IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
     public System.Void ThrowIfInvalid()
   public class CommandLineConfigurationException : System.Exception, System.Runtime.Serialization.ISerializable
     .ctor(System.String message)
@@ -149,8 +151,6 @@ System.CommandLine
     public System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.OptionResult>> Validators { get; }
     public System.Type ValueType { get; }
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
-    public ParseResult Parse(System.String commandLine)
-    public ParseResult Parse(System.String[] args)
   public class Option<T> : Option, IValueDescriptor<T>, System.CommandLine.Binding.IValueDescriptor
     .ctor(System.String name, System.String description = null)
     .ctor(System.String[] aliases, System.String description = null)
@@ -170,9 +170,9 @@ System.CommandLine
     public static Option<T> AcceptExistingOnly<T>(this Option<T> option)
   public class ParseResult
     public System.CommandLine.Parsing.CommandResult CommandResult { get; }
+    public CommandLineConfiguration Configuration { get; }
     public System.Collections.Generic.IReadOnlyDictionary<System.String,System.Collections.Generic.IReadOnlyList<System.String>> Directives { get; }
     public System.Collections.Generic.IReadOnlyList<System.CommandLine.Parsing.ParseError> Errors { get; }
-    public System.CommandLine.Parsing.Parser Parser { get; }
     public System.CommandLine.Parsing.CommandResult RootCommandResult { get; }
     public System.Collections.Generic.IReadOnlyList<System.CommandLine.Parsing.Token> Tokens { get; }
     public System.Collections.Generic.IReadOnlyList<System.String> UnmatchedTokens { get; }
@@ -184,6 +184,8 @@ System.CommandLine
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.Nullable<System.Int32> position = null)
     public T GetValue<T>(Argument<T> argument)
     public T GetValue<T>(Option<T> option)
+    public System.Int32 Invoke(IConsole console = null)
+    public System.Threading.Tasks.Task<System.Int32> InvokeAsync(IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
     public System.String ToString()
   public class RootCommand : Command, System.Collections.Generic.IEnumerable<Symbol>, System.Collections.IEnumerable
     public static System.String ExecutableName { get; }
@@ -286,7 +288,6 @@ System.CommandLine.Invocation
     public System.Int32 ExitCode { get; set; }
     public System.CommandLine.Help.HelpBuilder HelpBuilder { get; }
     public System.Action<InvocationContext> InvocationResult { get; set; }
-    public System.CommandLine.Parsing.Parser Parser { get; }
     public System.CommandLine.ParseResult ParseResult { get; set; }
     public T GetValue<T>(Option<T> option)
     public T GetValue<T>(Argument<T> argument)
@@ -359,22 +360,11 @@ System.CommandLine.Parsing
     public System.String Message { get; }
     public SymbolResult SymbolResult { get; }
     public System.String ToString()
-  public class Parser
-    .ctor(System.CommandLine.CommandLineConfiguration configuration)
-    .ctor(System.CommandLine.Command command)
-    public System.CommandLine.CommandLineConfiguration Configuration { get; }
-    public System.CommandLine.ParseResult Parse(System.Collections.Generic.IReadOnlyList<System.String> arguments, System.String rawInput = null)
+  public static class Parser
+    public static System.CommandLine.ParseResult Parse(System.CommandLine.Command command, System.Collections.Generic.IReadOnlyList<System.String> args, System.CommandLine.CommandLineConfiguration configuration = null)
+    public static System.CommandLine.ParseResult Parse(System.CommandLine.Command command, System.String commandLine, System.CommandLine.CommandLineConfiguration configuration = null)
   public static class ParseResultExtensions
     public static System.String Diagram(this System.CommandLine.ParseResult parseResult)
-    public static System.Boolean HasOption(this System.CommandLine.ParseResult parseResult, System.CommandLine.Option option)
-    public static System.Int32 Invoke(this System.CommandLine.ParseResult parseResult, System.CommandLine.IConsole console = null)
-    public static System.Threading.Tasks.Task<System.Int32> InvokeAsync(this System.CommandLine.ParseResult parseResult, System.CommandLine.IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
-  public static class ParserExtensions
-    public static System.Int32 Invoke(this Parser parser, System.String commandLine, System.CommandLine.IConsole console = null)
-    public static System.Int32 Invoke(this Parser parser, System.String[] args, System.CommandLine.IConsole console = null)
-    public static System.Threading.Tasks.Task<System.Int32> InvokeAsync(this Parser parser, System.String commandLine, System.CommandLine.IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
-    public static System.Threading.Tasks.Task<System.Int32> InvokeAsync(this Parser parser, System.String[] args, System.CommandLine.IConsole console = null, System.Threading.CancellationToken cancellationToken = null)
-    public static System.CommandLine.ParseResult Parse(this Parser parser, System.String commandLine)
   public abstract class SymbolResult
     public SymbolResult Parent { get; }
     public System.Collections.Generic.IReadOnlyList<Token> Tokens { get; }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
index 4fa64d7cea..dce90160e9 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
@@ -13,23 +13,24 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_CustomScenarios
     {
         private string _testSymbolsAsString;
-        private Parser _testParser;
+        private Command _rootCommand;
+        private CommandLineConfiguration _configuration;
 
         [GlobalSetup(Target = nameof(OneOptWithNestedCommand_Parse))]
         public void SetupOneOptWithNestedCommand()
         {
-            var rootCommand = new Command("root_command");
+            _rootCommand = new Command("root_command");
             var nestedCommand = new Command("nested_command");
             var option = new Option<int>("-opt1", () => 123);
             nestedCommand.Options.Add(option);
-            rootCommand.Subcommands.Add(nestedCommand);
+            _rootCommand.Subcommands.Add(nestedCommand);
 
-            _testParser = new Parser(rootCommand);
             _testSymbolsAsString = "root_command nested_command -opt1 321";
+            _configuration = CommandLineConfiguration.CreateBuilder(_rootCommand).UseDefaults().Build();
         }
 
         [Benchmark]
         public ParseResult OneOptWithNestedCommand_Parse() 
-            => _testParser.Parse(_testSymbolsAsString);
+            => _rootCommand.Parse(_testSymbolsAsString, _configuration);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
index 14760434fa..b24c96fcb1 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
@@ -15,7 +15,7 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_Directives_Suggest
     {
         private NullConsole _nullConsole;
-        private Parser _testParser;
+        private CommandLineConfiguration _configuration;
 
         [GlobalSetup]
         public void Setup()
@@ -34,7 +34,7 @@ public void Setup()
                 vegetableOption
             };
 
-            _testParser = new CommandLineBuilder(eatCommand)
+            _configuration = new CommandLineBuilder(eatCommand)
                 .UseSuggestDirective()
                 .Build();
         }
@@ -47,7 +47,7 @@ public void Setup()
 
         [Benchmark]
         public Task InvokeSuggest()
-            => _testParser.InvokeAsync(TestCmdArgs, _nullConsole);
+            => _configuration.InvokeAsync(TestCmdArgs, _nullConsole);
 
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
index e530aa8107..e5c2aecfd8 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
@@ -13,8 +13,8 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_NestedCommands
     {
         private string _testSymbolsAsString;
-        private Parser _testParser;
         private Command _rootCommand;
+        private CommandLineConfiguration _configuration;
 
         /// <remarks>
         /// 1 - cmd-root
@@ -45,7 +45,7 @@ private void GenerateTestNestedCommands(Command parent, int depth, int countPerL
             }
         }
 
-        [GlobalSetup(Target = nameof(ParserFromNestedCommands_Ctor))]
+        [GlobalSetup]
         public void SetupRootCommand()
         {
             string rootCommandName = "root";
@@ -62,19 +62,10 @@ public void SetupRootCommand()
             }
 
             _rootCommand = rootCommand;
+            _configuration = CommandLineConfiguration.CreateBuilder(rootCommand).UseDefaults().Build();
         }
 
-        [GlobalSetup(Target = nameof(Parser_Parse))]
-        public void SetupParser()
-        {
-            SetupRootCommand();
-            _testParser = new Parser(_rootCommand);
-        }
-
-        [Benchmark]
-        public Parser ParserFromNestedCommands_Ctor() => new(_rootCommand);
-
         [Benchmark]
-        public ParseResult Parser_Parse() => _testParser.Parse(_testSymbolsAsString);
+        public ParseResult Parser_Parse() => Parser.Parse(_rootCommand, _testSymbolsAsString, _configuration);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
index ca6d9d3a70..67f0d5e3b4 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
@@ -17,7 +17,7 @@ public class Perf_Parser_Options_Bare
     {
         private IEnumerable<Option> _testSymbols;
         private string _testSymbolsAsString;
-        private Parser _testParser;
+        private CommandLineConfiguration _testConfiguration;
 
         private IEnumerable<Option> GenerateTestOptions(int count, ArgumentArity arity)
             => Enumerable.Range(0, count)
@@ -49,20 +49,20 @@ public void SetupTestOptions()
         }
 
         [Benchmark]
-        public Parser ParserFromOptions_Ctor()
+        public CommandLineConfiguration ParserFromOptions_Ctor()
         {
-            return _testSymbols.CreateParser();
+            return _testSymbols.CreateConfiguration();
         }
 
         [GlobalSetup(Target = nameof(ParserFromOptions_Parse))]
         public void SetupParserFromOptions_Parse()
         {
             var testSymbolsArr = GenerateTestOptions(TestSymbolsCount, ArgumentArity.Zero).ToArray();
-            _testParser = testSymbolsArr.CreateParser();
+            _testConfiguration = testSymbolsArr.CreateConfiguration();
             _testSymbolsAsString = GenerateTestOptionsAsStringExpr(testSymbolsArr.Length);
         }
 
         [Benchmark]
-        public ParseResult ParserFromOptions_Parse() => _testParser.Parse(_testSymbolsAsString);
+        public ParseResult ParserFromOptions_Parse() => _testConfiguration.RootCommand.Parse(_testSymbolsAsString, _testConfiguration);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
index 63a4e9c996..f7cf13933b 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
@@ -16,7 +16,7 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_Options_With_Arguments
     {
         private string _testSymbolsAsString;
-        private Parser _testParser;
+        private CommandLineConfiguration _configuration;
 
         private IEnumerable<Option> GenerateTestOptions(int count, ArgumentArity arity)
             => Enumerable.Range(0, count)
@@ -54,11 +54,11 @@ private string GenerateTestOptionsWithArgumentsAsStringExpr(int optionsCount, in
         public void SetupParserFromOptionsWithArguments_Parse()
         {
             var testSymbolsArr = GenerateTestOptions(TestOptionsCount, ArgumentArity.OneOrMore).ToArray();
-            _testParser = testSymbolsArr.CreateParser();
+            _configuration = testSymbolsArr.CreateConfiguration();
             _testSymbolsAsString = GenerateTestOptionsWithArgumentsAsStringExpr(testSymbolsArr.Length, TestArgumentsCount);
         }
 
         [Benchmark]
-        public ParseResult ParserFromOptionsWithArguments_Parse() => _testParser.Parse(_testSymbolsAsString);
+        public ParseResult ParserFromOptionsWithArguments_Parse() => _configuration.RootCommand.Parse(_testSymbolsAsString, _configuration);
     }
 }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
index be4be31cbe..381cd5be9e 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
@@ -15,13 +15,13 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Parser_ParseResult
     {
-        private readonly Parser _testParser;
+        private readonly CommandLineConfiguration _configuration;
 
         public Perf_Parser_ParseResult()
         {
             var option = new Option<bool>("-opt");
 
-            _testParser =
+            _configuration =
                 new CommandLineBuilder(new RootCommand { option })
                     .UseParseDirective()
                     .Build();
@@ -39,12 +39,12 @@ public IEnumerable<string> GenerateTestInputs()
 
         public IEnumerable<object> GenerateTestParseResults()
             => GenerateTestInputs()
-               .Select(input => new BdnParam<ParseResult>(_testParser.Parse(input), input));
+               .Select(input => new BdnParam<ParseResult>(_configuration.RootCommand.Parse(input, _configuration), input));
 
         [Benchmark]
         [ArgumentsSource(nameof(GenerateTestInputs))]
         public IReadOnlyDictionary<string, IReadOnlyList<string>> ParseResult_Directives(string input)
-            => _testParser.Parse(input).Directives;
+            => _configuration.RootCommand.Parse(input, _configuration).Directives;
 
         [Benchmark]
         [ArgumentsSource(nameof(GenerateTestParseResults))]
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
index 9549dc340f..53dc1887dc 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
@@ -17,13 +17,13 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_TypoCorrection
     {
         private readonly NullConsole _nullConsole = new();
-        private readonly Parser _testParser;
+        private readonly CommandLineConfiguration _configuration;
 
         public Perf_Parser_TypoCorrection()
         {
             var option = new Option<bool>("--0123456789");
 
-            _testParser = new CommandLineBuilder(new RootCommand { option })
+            _configuration = new CommandLineBuilder(new RootCommand { option })
                           .UseTypoCorrections()
                           .Build();
         }
@@ -49,7 +49,7 @@ public IEnumerable<BdnParam<ParseResult>> GenerateTestParseResults()
                     "--1023546798",
                     "--1032546798"
                 }
-                .Select(opt => new BdnParam<ParseResult>(_testParser.Parse(opt), opt));
+                .Select(opt => new BdnParam<ParseResult>(_configuration.RootCommand.Parse(opt, _configuration), opt));
 
         [Benchmark]
         [ArgumentsSource(nameof(GenerateTestParseResults))]
diff --git a/src/System.CommandLine.Benchmarks/Helpers/Utils.cs b/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
index bcadd1bfc1..b030fc4aab 100644
--- a/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
+++ b/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
@@ -44,7 +44,7 @@ internal static string CreateTestAssemblyInTempFileFromString(string sourceCode,
             return pathToAssemblyFile;
         }
 
-        public static Parser CreateParser(this IEnumerable<Option> symbols)
+        public static CommandLineConfiguration CreateConfiguration(this IEnumerable<Option> symbols)
         {
             var rootCommand = new RootCommand();
 
@@ -53,7 +53,7 @@ public static Parser CreateParser(this IEnumerable<Option> symbols)
                 rootCommand.Add(symbol);
             }
 
-            return new Parser(rootCommand);
+            return CommandLineConfiguration.CreateBuilder(rootCommand).UseDefaults().Build();
         }
     }
 }
diff --git a/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs b/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs
index fd9544b876..cd95085f2a 100644
--- a/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs
+++ b/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs
@@ -25,12 +25,12 @@ public class ConfigureFromMethodTests
         [Fact]
         public async Task Generated_boolean_parameters_will_accept_zero_arguments()
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_taking_bool)), this)
                          .Build();
 
-            await parser.InvokeAsync($"{RootCommand.ExecutableName} --value", _testConsole);
+            await config.InvokeAsync($"{RootCommand.ExecutableName} --value", _testConsole);
 
             _receivedValues.Should().BeEquivalentTo(true);
         }
@@ -44,12 +44,12 @@ public async Task Generated_boolean_parameters_will_accept_zero_arguments()
         [InlineData("--value=false", false)]
         public async Task Generated_boolean_parameters_will_accept_one_argument(string commandLine, bool expected)
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_taking_bool)), this)
                          .Build();
 
-            await parser.InvokeAsync(commandLine, _testConsole);
+            await config.InvokeAsync(commandLine, _testConsole);
 
             _receivedValues.Should().BeEquivalentTo(expected);
         }
@@ -57,12 +57,12 @@ public async Task Generated_boolean_parameters_will_accept_one_argument(string c
         [Fact]
         public async Task Single_character_parameters_generate_aliases_that_accept_a_single_dash_prefix()
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_with_single_letter_parameters)), this)
                          .Build();
 
-            await parser.InvokeAsync("-x 123 -y 456", _testConsole);
+            await config.InvokeAsync("-x 123 -y 456", _testConsole);
 
             _receivedValues.Should()
                            .BeEquivalentSequenceTo(123, 456);
@@ -82,11 +82,11 @@ public void Parameters_named_arguments_generate_command_arguments_having_the_cor
             int minNumberOfValues,
             int maxNumberOfValues)
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName))
                          .Build();
 
-            var rootCommandArgument = parser.Configuration.RootCommand.Arguments.Single();
+            var rootCommandArgument = config.RootCommand.Arguments.Single();
 
             rootCommandArgument.Arity
                                .Should()
@@ -103,11 +103,11 @@ public void Parameters_named_arguments_generate_command_arguments_having_the_cor
         [InlineData(nameof(Method_having_FileInfo_array_args), "args")]
         public void Parameters_named_arguments_generate_command_arguments_having_the_correct_name(string methodName, string expectedArgName)
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName))
                          .Build();
 
-            var rootCommandArgument = parser.Configuration.RootCommand.Arguments.Single();
+            var rootCommandArgument = config.RootCommand.Arguments.Single();
 
             rootCommandArgument.Name
                                .Should()
@@ -124,11 +124,11 @@ public void Parameters_named_arguments_generate_command_arguments_having_the_cor
         [InlineData(nameof(Method_having_FileInfo_array_args))]
         public void Options_are_not_generated_for_command_argument_parameters(string methodName)
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName))
                          .Build();
 
-            var rootCommand = parser.Configuration.RootCommand;
+            var rootCommand = config.RootCommand;
 
             var argumentParameterNames = new[]
                                          {
@@ -154,11 +154,11 @@ public void Parameters_named_arguments_generate_command_arguments_having_the_cor
             string methodName,
             Type expectedType)
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName))
                          .Build();
 
-            var rootCommandArgument = parser.Configuration.RootCommand.Arguments.Single();
+            var rootCommandArgument = config.RootCommand.Arguments.Single();
 
             rootCommandArgument.ValueType
                                .Should()
@@ -168,12 +168,12 @@ public void Parameters_named_arguments_generate_command_arguments_having_the_cor
         [Fact]
         public async Task When_method_returns_void_then_return_code_is_0()
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_returning_void)), this)
                          .Build();
 
-            var result = await parser.InvokeAsync("", _testConsole);
+            var result = await config.InvokeAsync("", _testConsole);
 
             result.Should().Be(0);
         }
@@ -181,12 +181,12 @@ public async Task When_method_returns_void_then_return_code_is_0()
         [Fact]
         public async Task When_method_returns_int_then_return_code_is_set_to_return_value()
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_returning_int)), this)
                          .Build();
 
-            var result = await parser.InvokeAsync("-i 123", _testConsole);
+            var result = await config.InvokeAsync("-i 123", _testConsole);
 
             result.Should().Be(123);
         }
@@ -194,12 +194,12 @@ public async Task When_method_returns_int_then_return_code_is_set_to_return_valu
         [Fact]
         public async Task When_method_returns_Task_of_int_then_return_code_is_set_to_return_value()
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_returning_Task_of_int)), this)
                          .Build();
 
-            var result = await parser.InvokeAsync("-i 123", _testConsole);
+            var result = await config.InvokeAsync("-i 123", _testConsole);
 
             result.Should().Be(123);
         }
diff --git a/src/System.CommandLine.DragonFruit/CommandLine.cs b/src/System.CommandLine.DragonFruit/CommandLine.cs
index 9c2a7bf9f7..113dba6990 100644
--- a/src/System.CommandLine.DragonFruit/CommandLine.cs
+++ b/src/System.CommandLine.DragonFruit/CommandLine.cs
@@ -86,9 +86,9 @@ public static Task<int> InvokeMethodAsync(
             object target = null,
             IConsole console = null)
         {
-            Parser parser = BuildParser(method, xmlDocsFilePath, target);
+            CommandLineConfiguration configuration = BuildConfiguration(method, xmlDocsFilePath, target);
 
-            return parser.InvokeAsync(args, console);
+            return configuration.InvokeAsync(args, console);
         }
 
         public static int InvokeMethod(
@@ -98,22 +98,22 @@ public static int InvokeMethod(
             object target = null,
             IConsole console = null)
         {
-            Parser parser = BuildParser(method, xmlDocsFilePath, target);
+            CommandLineConfiguration configuration = BuildConfiguration(method, xmlDocsFilePath, target);
 
-            return parser.Invoke(args, console);
+            return configuration.Invoke(args, console);
         }
 
-        private static Parser BuildParser(MethodInfo method,
+        private static CommandLineConfiguration BuildConfiguration(MethodInfo method,
             string xmlDocsFilePath,
             object target)
         {
-            var builder = new CommandLineBuilder()
+            var builder = new CommandLineBuilder(new RootCommand())
                 .ConfigureRootCommandFromMethod(method, target)
                 .ConfigureHelpFromXmlComments(method, xmlDocsFilePath)
                 .UseDefaults()
                 .UseAnsiTerminalWhenAvailable();
 
-            return  builder.Build();
+            return builder.Build();
         }
 
         public static CommandLineBuilder ConfigureRootCommandFromMethod(
diff --git a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
index 72a4cb4995..3eac19d295 100644
--- a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
+++ b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
@@ -19,7 +19,7 @@ public static async Task Constructor_Injection_Injects_Service()
         {
             var service = new MyService();
 
-            var parser = new CommandLineBuilder(
+            var config = new CommandLineBuilder(
                 new MyCommand()
                 )
                 .UseHost((builder) => {
@@ -31,7 +31,7 @@ public static async Task Constructor_Injection_Injects_Service()
                 })
                 .Build();
 
-            var result = await parser.InvokeAsync(new string[] { "--int-option", "54"});
+            var result = await config.InvokeAsync(new string[] { "--int-option", "54"});
 
             service.Value.Should().Be(54);
         }
@@ -39,7 +39,7 @@ public static async Task Constructor_Injection_Injects_Service()
         [Fact]
         public static async Task Parameter_is_available_in_property()
         {
-            var parser = new CommandLineBuilder(new MyCommand())
+            var config = new CommandLineBuilder(new MyCommand())
                 .UseHost(host =>
                 {
                     host.ConfigureServices(services =>
@@ -50,7 +50,7 @@ public static async Task Parameter_is_available_in_property()
                 })
                 .Build();
 
-            var result = await parser.InvokeAsync(new string[] { "--int-option", "54"});
+            var result = await config.InvokeAsync(new string[] { "--int-option", "54"});
 
             result.Should().Be(54);
         }
@@ -62,7 +62,7 @@ public static async Task Can_have_different_handlers_based_on_command()
 
             root.Subcommands.Add(new MyCommand());
             root.Subcommands.Add(new MyOtherCommand());
-            var parser = new CommandLineBuilder(root)
+            var config = new CommandLineBuilder(root)
                 .UseHost(host =>
                 {
                     host.ConfigureServices(services =>
@@ -77,11 +77,11 @@ public static async Task Can_have_different_handlers_based_on_command()
                 })
                 .Build();
 
-            var result = await parser.InvokeAsync(new string[] { "mycommand", "--int-option", "54" });
+            var result = await config.InvokeAsync(new string[] { "mycommand", "--int-option", "54" });
 
             result.Should().Be(54);
 
-            result = await parser.InvokeAsync(new string[] { "myothercommand", "--int-option", "54" });
+            result = await config.InvokeAsync(new string[] { "myothercommand", "--int-option", "54" });
 
             result.Should().Be(100);
         }
@@ -92,7 +92,7 @@ public static async Task Can_bind_to_arguments_via_injection()
             var service = new MyService();
             var cmd = new RootCommand();
             cmd.Subcommands.Add(new MyOtherCommand());
-            var parser = new CommandLineBuilder(cmd)
+            var config = new CommandLineBuilder(cmd)
                 .UseHost(host =>
                 {
                     host.ConfigureServices(services =>
@@ -103,7 +103,7 @@ public static async Task Can_bind_to_arguments_via_injection()
                 })
                 .Build();
 
-            var result = await parser.InvokeAsync(new string[] { "myothercommand", "TEST" });
+            var result = await config.InvokeAsync(new string[] { "myothercommand", "TEST" });
 
             service.StringValue.Should().Be("TEST");
         }
@@ -116,7 +116,7 @@ public static async Task Invokes_DerivedClass()
             var cmd = new RootCommand();
             cmd.Subcommands.Add(new MyCommand());
             cmd.Subcommands.Add(new MyOtherCommand());
-            var parser = new CommandLineBuilder(cmd)
+            var config = new CommandLineBuilder(cmd)
                          .UseHost((builder) => {
                              builder.ConfigureServices(services =>
                              {
@@ -127,10 +127,10 @@ public static async Task Invokes_DerivedClass()
                          })
                          .Build();
 
-            await parser.InvokeAsync(new string[] { "mycommand", "--int-option", "54" });
+            await config.InvokeAsync(new string[] { "mycommand", "--int-option", "54" });
             service.Value.Should().Be(54);
 
-            await parser.InvokeAsync(new string[] { "myothercommand", "TEST" });
+            await config.InvokeAsync(new string[] { "myothercommand", "TEST" });
             service.StringValue.Should().Be("TEST");
         }
 
diff --git a/src/System.CommandLine.Hosting.Tests/HostingTests.cs b/src/System.CommandLine.Hosting.Tests/HostingTests.cs
index a1e3d2b362..07957a07d4 100644
--- a/src/System.CommandLine.Hosting.Tests/HostingTests.cs
+++ b/src/System.CommandLine.Hosting.Tests/HostingTests.cs
@@ -27,13 +27,13 @@ void Execute(IHost host)
                 hostFromHandler = host;
             }
 
-            var parser = new CommandLineBuilder(
+            var config = new CommandLineBuilder(
                 new RootCommand { Handler = CommandHandler.Create<IHost>(Execute) }
                 )
                 .UseHost()
                 .Build();
 
-            parser.InvokeAsync(Array.Empty<string>())
+            config.InvokeAsync(Array.Empty<string>())
                 .GetAwaiter().GetResult();
 
             hostFromHandler.Should().NotBeNull();
@@ -44,7 +44,7 @@ public static void UseHost_adds_invocation_context_to_HostBuilder_Properties()
         {
             InvocationContext invocationContext = null;
 
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                 .UseHost(host =>
                 {
                     if (host.Properties.TryGetValue(typeof(InvocationContext), out var ctx))
@@ -52,7 +52,7 @@ public static void UseHost_adds_invocation_context_to_HostBuilder_Properties()
                 })
                 .Build();
 
-            parser.InvokeAsync(Array.Empty<string>())
+            config.InvokeAsync(Array.Empty<string>())
                 .GetAwaiter().GetResult();
 
             invocationContext.Should().NotBeNull();
@@ -75,13 +75,13 @@ void Execute(IHost host)
                 console = services.GetRequiredService<IConsole>();
             }
 
-            var parser = new CommandLineBuilder(
+            var config = new CommandLineBuilder(
                 new RootCommand { Handler = CommandHandler.Create<IHost>(Execute) }
                 )
                 .UseHost()
                 .Build();
 
-            parser.InvokeAsync(Array.Empty<string>())
+            config.InvokeAsync(Array.Empty<string>())
                 .GetAwaiter().GetResult();
 
             invocationContext.Should().NotBeNull();
@@ -105,7 +105,7 @@ void Execute(IHost host)
                 testConfigValue = config[testKey];
             }
 
-            var parser = new CommandLineBuilder(
+            var config = new CommandLineBuilder(
                 new RootCommand
                 {
                     Handler = CommandHandler.Create<IHost>(Execute),
@@ -121,7 +121,7 @@ void Execute(IHost host)
                 })
                 .Build();
 
-            parser.InvokeAsync(commandLineArgs)
+            config.InvokeAsync(commandLineArgs)
                 .GetAwaiter().GetResult();
 
             testConfigValue.Should().BeEquivalentTo(testArgument);
@@ -142,7 +142,7 @@ void Execute(IHost host)
                 testConfigValue = config[testKey];
             }
 
-            var parser = new CommandLineBuilder(
+            var config = new CommandLineBuilder(
                 new RootCommand
                 {
                     Handler = CommandHandler.Create<IHost>(Execute),
@@ -160,7 +160,7 @@ void Execute(IHost host)
                 })
                 .Build();
 
-            parser.InvokeAsync(commandLineArgs)
+            config.InvokeAsync(commandLineArgs)
                 .GetAwaiter().GetResult();
 
             testConfigValue.Should().BeEquivalentTo(testArgument);
@@ -181,7 +181,7 @@ void Execute(IHost host)
                 testConfigValue = config[testKey];
             }
 
-            var parser = new CommandLineBuilder(
+            var config = new CommandLineBuilder(
                 new RootCommand
                 {
                     Handler = CommandHandler.Create<IHost>(Execute)
@@ -189,7 +189,7 @@ void Execute(IHost host)
                 .UseHost()
                 .Build();
 
-            parser.InvokeAsync(commandLine).GetAwaiter().GetResult();
+            config.InvokeAsync(commandLine).GetAwaiter().GetResult();
 
             testConfigValue.Should().BeEquivalentTo(testValue);
         }
@@ -260,7 +260,7 @@ public void SubCommand(int myArgument)
         public static void GetInvocationContext_returns_non_null_instance()
         {
             bool ctxAsserted = false;
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                 .UseHost(hostBuilder =>
                 {
                     InvocationContext ctx = hostBuilder.GetInvocationContext();
@@ -269,7 +269,7 @@ public static void GetInvocationContext_returns_non_null_instance()
                 })
                 .Build();
 
-            _ = parser.Invoke(string.Empty);
+            _ = config.Invoke(string.Empty);
             ctxAsserted.Should().BeTrue();
         }
 
@@ -277,7 +277,7 @@ public static void GetInvocationContext_returns_non_null_instance()
         public static void GetInvocationContext_in_ConfigureServices_returns_non_null_instance()
         {
             bool ctxAsserted = false;
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                 .UseHost(hostBuilder =>
                 {
                     hostBuilder.ConfigureServices((hostingCtx, services) =>
@@ -289,7 +289,7 @@ public static void GetInvocationContext_in_ConfigureServices_returns_non_null_in
                 })
                 .Build();
 
-            _ = parser.Invoke(string.Empty);
+            _ = config.Invoke(string.Empty);
             ctxAsserted.Should().BeTrue();
         }
 
@@ -299,7 +299,7 @@ public static void GetInvocationContext_returns_same_instance_as_outer_middlewar
             InvocationContext ctxCustom = null;
             InvocationContext ctxHosting = null;
 
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                 .AddMiddleware((context, cancellationToken, next) =>
                 {
                     ctxCustom = context;
@@ -311,7 +311,7 @@ public static void GetInvocationContext_returns_same_instance_as_outer_middlewar
                 })
                 .Build();
 
-            _ = parser.Invoke(string.Empty);
+            _ = config.Invoke(string.Empty);
 
             ctxHosting.Should().BeSameAs(ctxCustom);
         }
@@ -322,7 +322,7 @@ public static void GetInvocationContext_in_ConfigureServices_returns_same_instan
             InvocationContext ctxCustom = null;
             InvocationContext ctxConfigureServices = null;
 
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                 .AddMiddleware((context, cancellationToken, next) =>
                 {
                     ctxCustom = context;
@@ -337,7 +337,7 @@ public static void GetInvocationContext_in_ConfigureServices_returns_same_instan
                 })
                 .Build();
 
-            _ = parser.Invoke(string.Empty);
+            _ = config.Invoke(string.Empty);
 
             ctxConfigureServices.Should().BeSameAs(ctxCustom);
         }
@@ -371,7 +371,7 @@ public static void GetInvocationContext_in_ConfigureServices_throws_if_not_withi
         public static void GetHost_returns_non_null_instance_in_subsequent_middleware()
         {
             bool hostAsserted = false;
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                 .UseHost()
                 .AddMiddleware((invCtx, cancellationToken, next) =>
                 {
@@ -383,7 +383,7 @@ public static void GetHost_returns_non_null_instance_in_subsequent_middleware()
                 })
                 .Build();
 
-            _ = parser.Invoke(string.Empty);
+            _ = config.Invoke(string.Empty);
 
             hostAsserted.Should().BeTrue();
         }
@@ -392,7 +392,7 @@ public static void GetHost_returns_non_null_instance_in_subsequent_middleware()
         public static void GetHost_returns_null_when_no_host_in_invocation()
         {
             bool hostAsserted = false;
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                 .AddMiddleware((invCtx, cancellationToken, next) =>
                 {
                     IHost host = invCtx.GetHost();
@@ -403,7 +403,7 @@ public static void GetHost_returns_null_when_no_host_in_invocation()
                 })
                 .Build();
 
-            _ = parser.Invoke(string.Empty);
+            _ = config.Invoke(string.Empty);
 
             hostAsserted.Should().BeTrue();
         }
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
index 064b93a9e4..02014170d4 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
@@ -104,8 +104,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_constru
         command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithMultiLetterCtorParameters));
 
-        var parser = new Parser(command);
-        var bindingContext = new InvocationContext(parser.Parse("")).BindingContext;
+        var bindingContext = new InvocationContext(Parser.Parse(command, "")).BindingContext;
 
         var instance = (ClassWithMultiLetterCtorParameters)binder.CreateInstance(bindingContext);
 
@@ -129,9 +128,8 @@ public void Option_arguments_are_bound_by_name_to_property_setters(
         {
             OptionBuilder.CreateOption("--value", type)
         };
-        var parser = new Parser(command);
 
-        var bindingContext = new InvocationContext(parser.Parse(commandLine)).BindingContext;
+        var bindingContext = new InvocationContext(command.Parse(commandLine)).BindingContext;
 
         var instance = binder.CreateInstance(bindingContext);
 
@@ -157,9 +155,8 @@ public void Command_arguments_are_bound_by_name_to_property_setters(
         {
             ArgumentBuilder.CreateArgument(type)
         };
-        var parser = new Parser(command);
 
-        var bindingContext = new InvocationContext(parser.Parse(commandLine)).BindingContext;
+        var bindingContext = new InvocationContext(command.Parse(commandLine)).BindingContext;
 
         var instance = binder.CreateInstance(bindingContext);
 
@@ -194,8 +191,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_propert
         command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithSetter<string>));
 
-        var parser = new Parser(command);
-        var bindingContext = new InvocationContext(parser.Parse("")).BindingContext;
+        var bindingContext = new InvocationContext(command.Parse("")).BindingContext;
 
         var instance = (ClassWithSetter<string>)binder.CreateInstance(bindingContext);
 
@@ -212,9 +208,8 @@ public void Property_setters_with_no_default_value_and_no_matching_option_are_no
 
         var binder = new ModelBinder(typeof(ClassWithSettersAndCtorParametersWithDifferentNames));
 
-        var parser = new Parser(command);
         var bindingContext = new InvocationContext(
-            parser.Parse("")).BindingContext;
+            command.Parse("")).BindingContext;
 
         var instance = (ClassWithSettersAndCtorParametersWithDifferentNames)binder.CreateInstance(bindingContext);
 
@@ -224,11 +219,11 @@ public void Property_setters_with_no_default_value_and_no_matching_option_are_no
     [Fact]
     public void Parse_result_can_be_used_to_create_an_instance_without_doing_handler_invocation()
     {
-        var parser = new Parser(new Command("the-command")
+        Command command = new ("the-command")
         {
             new Option<int>("--int-option")
-        });
-        var bindingContext = new InvocationContext(parser.Parse("the-command --int-option 123")).BindingContext;
+        };
+        var bindingContext = new InvocationContext(command.Parse("the-command --int-option 123")).BindingContext;
         var binder = new ModelBinder(typeof(ClassWithMultiLetterSetters));
 
         var instance = (ClassWithMultiLetterSetters)binder.CreateInstance(bindingContext);
@@ -239,12 +234,12 @@ public void Parse_result_can_be_used_to_create_an_instance_without_doing_handler
     [Fact]
     public void Parse_result_can_be_used_to_modify_an_existing_instance_without_doing_handler_invocation()
     {
-        var parser = new Parser(new Command("the-command")
+        Command command = new("the-command")
         {
             new Option<int>("--int-option")
-        });
+        };
         var instance = new ClassWithMultiLetterSetters();
-        var bindingContext = new InvocationContext(parser.Parse("the-command --int-option 123")).BindingContext;
+        var bindingContext = new InvocationContext(command.Parse("the-command --int-option 123")).BindingContext;
         var binder = new ModelBinder(typeof(ClassWithMultiLetterSetters));
 
         binder.UpdateInstance(instance, bindingContext);
@@ -255,7 +250,7 @@ public void Parse_result_can_be_used_to_modify_an_existing_instance_without_doin
     [Fact]
     public void Modify_an_existing_instance_should_keep_all_default_values_if_no_argument_matches_option()
     {
-        var parser = new Parser(new Command("the-command"));
+        Command parser = new ("the-command");
 
         var instance = new ClassWithComplexTypes();
         var bindingContext = new InvocationContext(parser.Parse("the-command")).BindingContext;
@@ -481,7 +476,7 @@ public void Option_argument_is_bound_to_longest_constructor()
     {
         var option = new Option<int>("--int-property");
 
-        var bindingContext = new InvocationContext(option.Parse("--int-property 42")).BindingContext;
+        var bindingContext = new InvocationContext(new RootCommand { option }.Parse("--int-property 42")).BindingContext;
         var binder = new ModelBinder<ClassWithMultipleCtor>();
         var instance = binder.CreateInstance(bindingContext) as ClassWithMultipleCtor;
 
@@ -494,9 +489,8 @@ public void Command_argument_is_bound_to_longest_constructor()
     {
         var rootCommand = new RootCommand();
         rootCommand.Arguments.Add(new Argument<int> { Name = nameof(ClassWithMultipleCtor.IntProperty) });
-        var parser = new Parser(rootCommand);
 
-        var bindingContext = new InvocationContext(parser.Parse("42")).BindingContext;
+        var bindingContext = new InvocationContext(rootCommand.Parse("42")).BindingContext;
         var binder = new ModelBinder<ClassWithMultipleCtor>();
         var instance = binder.CreateInstance(bindingContext) as ClassWithMultipleCtor;
 
@@ -509,9 +503,9 @@ public void Explicit_model_binder_binds_only_to_configured_properties()
     {
         var intOption = new Option<int>("--int-property");
         var stringOption = new Option<string>("--string-property");
-        var parser = new Parser(new RootCommand { intOption, stringOption });
+        RootCommand rootCommand = new RootCommand { intOption, stringOption };
 
-        var bindingContext = new InvocationContext(parser.Parse("--int-property 42 --string-property Hello")).BindingContext;
+        var bindingContext = new InvocationContext(rootCommand.Parse("--int-property 42 --string-property Hello")).BindingContext;
         var binder = new ModelBinder<ClassWithMultiLetterSetters>
         {
             EnforceExplicitBinding = true
@@ -616,7 +610,7 @@ public void Custom_ModelBinders_specified_via_BindingContext_can_be_used_for_opt
 
         rootCommand.Handler = CommandHandler.Create<ClassWithSetter<int>>(x => boundInstance = x);
 
-        var parser = new CommandLineBuilder(rootCommand)
+        var config = new CommandLineBuilder(rootCommand)
                      .AddMiddleware(context =>
                      {
                          var binder = new ModelBinder<ClassWithSetter<int>>();
@@ -627,7 +621,7 @@ public void Custom_ModelBinders_specified_via_BindingContext_can_be_used_for_opt
                      })
                      .Build();
 
-        parser.Invoke("--value 123");
+        config.Invoke("--value 123");
 
         boundInstance.Value.Should().Be(456);
     }
@@ -644,7 +638,7 @@ public void Custom_ModelBinders_specified_via_BindingContext_can_be_used_for_com
 
         rootCommand.Handler = CommandHandler.Create<ClassWithSetter<int>>(x => boundInstance = x);
 
-        var parser = new CommandLineBuilder(rootCommand)
+        var config = new CommandLineBuilder(rootCommand)
                      .AddMiddleware(context =>
                      {
                          var binder = new ModelBinder<ClassWithSetter<int>>();
@@ -655,7 +649,7 @@ public void Custom_ModelBinders_specified_via_BindingContext_can_be_used_for_com
                      })
                      .Build();
 
-        parser.Invoke("123");
+        config.Invoke("123");
 
         boundInstance.Value.Should().Be(456);
     }
@@ -676,10 +670,10 @@ public void Default_values_from_options_with_the_same_type_are_bound_and_use_the
             second = two;
         });
 
-        var parser = new CommandLineBuilder(rootCommand)
+        var config = new CommandLineBuilder(rootCommand)
             .Build();
 
-        parser.Invoke("");
+        config.Invoke("");
 
         first.Should().Be(1);
         second.Should().Be(2);
@@ -719,7 +713,7 @@ public async Task Empty_input_is_bound_correctly_to_list_type_properties()
             Handler = CommandHandler.Create((ClassWithListTypePropertiesAndDefaultCtor value) => { boundInstance = value; })
         };
 
-        var result = cmd.Parse();
+        var result = cmd.Parse(string.Empty);
 
         await result.InvokeAsync();
 
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
index fd104c8e0b..614e0eebe8 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
@@ -437,9 +437,7 @@ public async Task Method_invoked_is_matching_to_the_interface_implementation(Typ
         var command = new Command("command");
         command.Handler = CommandHandler.Create(type.GetMethod(nameof(ICommandHandler.InvokeAsync)));
 
-        var parser = new Parser(command);
-
-        int result = await parser.InvokeAsync("command", _console);
+        int result = await command.InvokeAsync("command", _console);
 
         result.Should().Be(expectedResult);
     }
diff --git a/src/System.CommandLine.Rendering.Tests/TerminalModeTests.cs b/src/System.CommandLine.Rendering.Tests/TerminalModeTests.cs
index 6f068f63a9..190a82afa6 100644
--- a/src/System.CommandLine.Rendering.Tests/TerminalModeTests.cs
+++ b/src/System.CommandLine.Rendering.Tests/TerminalModeTests.cs
@@ -48,11 +48,11 @@ public async Task Sets_output_mode_to_Ansi_when_specified_by_output_directive(Ou
                 return Task.FromResult(0);
             });
 
-            var parser = new CommandLineBuilder(command)
+            var config = new CommandLineBuilder(command)
                          .UseAnsiTerminalWhenAvailable()
                          .Build();
 
-            await parser.InvokeAsync($"[output:{specifiedOutputMode}]", console);
+            await config.InvokeAsync($"[output:{specifiedOutputMode}]", console);
 
             detectedOutputMode.Should().Be(specifiedOutputMode);
         }
diff --git a/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs b/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs
index 3412370872..b3d004b58b 100644
--- a/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs
+++ b/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs
@@ -31,7 +31,7 @@ public void Views_can_be_registered_for_specific_types()
                     })
             };
 
-            var parser = new CommandLineBuilder(command)
+            var config = new CommandLineBuilder(command)
                          .AddMiddleware(c =>
                          {
                              c.BindingContext
@@ -45,7 +45,7 @@ public void Views_can_be_registered_for_specific_types()
                 IsAnsiTerminal = false
             };
 
-            parser.Invoke("", terminal);
+            config.Invoke("", terminal);
 
             terminal.Out.ToString().Should().Contain(parseResult.Diagram());
         }
diff --git a/src/System.CommandLine.Suggest.Tests/SuggestionShellScriptHandlerTest.cs b/src/System.CommandLine.Suggest.Tests/SuggestionShellScriptHandlerTest.cs
index 5a96e6171d..be24110d7a 100644
--- a/src/System.CommandLine.Suggest.Tests/SuggestionShellScriptHandlerTest.cs
+++ b/src/System.CommandLine.Suggest.Tests/SuggestionShellScriptHandlerTest.cs
@@ -11,19 +11,19 @@ namespace System.CommandLine.Suggest.Tests
 {
     public class SuggestionShellScriptHandlerTest
     {
-        private readonly Parser _parser;
+        private readonly CommandLineConfiguration _configuration;
         private readonly TestConsole _console;
 
         public SuggestionShellScriptHandlerTest()
         {
-            _parser = new SuggestionDispatcher(new TestSuggestionRegistration()).Parser;
+            _configuration = new SuggestionDispatcher(new TestSuggestionRegistration()).Configuration;
             _console = new TestConsole();
         }
 
         [Fact]
         public async Task When_shell_type_is_not_supported_it_throws()
         {
-            await _parser.InvokeAsync(
+            await _configuration.InvokeAsync(
                 "script 123",
                 _console);
 
@@ -36,7 +36,7 @@ await _parser.InvokeAsync(
         [Fact]
         public async Task It_should_print_bash_shell_script()
         {
-            await _parser.InvokeAsync(
+            await _configuration.InvokeAsync(
                 "script bash",
                 _console);
 
@@ -46,7 +46,7 @@ await _parser.InvokeAsync(
         [Fact]
         public async Task It_should_print_powershell_shell_script()
         {
-            await _parser.InvokeAsync(
+            await _configuration.InvokeAsync(
                 "script powershell",
                 _console);
 
@@ -56,7 +56,7 @@ await _parser.InvokeAsync(
         [Fact]
         public async Task It_should_print_zsh_shell_script()
         {
-            await _parser.InvokeAsync(
+            await _configuration.InvokeAsync(
                 "script zsh",
                 _console);
             
diff --git a/src/System.CommandLine.Suggest/SuggestionDispatcher.cs b/src/System.CommandLine.Suggest/SuggestionDispatcher.cs
index 4f2e6a7df1..e8fd907f5c 100644
--- a/src/System.CommandLine.Suggest/SuggestionDispatcher.cs
+++ b/src/System.CommandLine.Suggest/SuggestionDispatcher.cs
@@ -7,7 +7,6 @@
 using System.CommandLine.Parsing;
 using System.IO;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace System.CommandLine.Suggest
@@ -76,7 +75,7 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug
                 CompleteScriptCommand
             };
             root.TreatUnmatchedTokensAsErrors = false;
-            Parser = new CommandLineBuilder(root)
+            Configuration = new CommandLineBuilder(root)
                      .UseVersionOption()
                      .UseHelp()
                      .UseParseDirective()
@@ -108,12 +107,12 @@ private static Option<FileInfo> GetExecutableOption()
 
         private Command RegisterCommand { get; }
 
-        public Parser Parser { get; }
+        public CommandLineConfiguration Configuration { get; }
 
         public TimeSpan Timeout { get; set; } = TimeSpan.FromMilliseconds(5000);
 
         public Task<int> InvokeAsync(string[] args, IConsole console = null) =>
-            Parser.InvokeAsync(args, console);
+            Configuration.InvokeAsync(args, console);
 
         private void Register(
             string commandPath,
diff --git a/src/System.CommandLine.Tests/ArgumentTests.cs b/src/System.CommandLine.Tests/ArgumentTests.cs
index a32a0afa71..391d9adfbf 100644
--- a/src/System.CommandLine.Tests/ArgumentTests.cs
+++ b/src/System.CommandLine.Tests/ArgumentTests.cs
@@ -128,7 +128,7 @@ public void Validation_failure_message_can_be_specified_when_parsing_tokens()
                     return null;
                 });
 
-                argument.Parse("x")
+                new RootCommand { argument }.Parse("x")
                         .Errors
                         .Should()
                         .ContainSingle(e => ((ArgumentResult)e.SymbolResult).Argument == argument)
@@ -147,7 +147,7 @@ public void Validation_failure_message_can_be_specified_when_evaluating_default_
                     return null;
                 }, true);
 
-                argument.Parse("")
+                new RootCommand { argument }.Parse("")
                         .Errors
                         .Should()
                         .ContainSingle(e => ((ArgumentResult)e.SymbolResult).Argument == argument)
@@ -168,7 +168,7 @@ public void Validation_failure_message_can_be_specified_when_evaluating_default_
                         return null;
                     }, true);
 
-                option.Parse("")
+                new RootCommand { option }.Parse("")
                       .Errors
                       .Should()
                       .ContainSingle()
@@ -183,7 +183,7 @@ public void custom_parsing_of_scalar_value_from_an_argument_with_one_token()
             {
                 var argument = new Argument<int>(result => int.Parse(result.Tokens.Single().Value));
 
-                argument.Parse("123")
+                new RootCommand { argument }.Parse("123")
                         .GetValue(argument)
                         .Should()
                         .Be(123);
@@ -194,7 +194,7 @@ public void custom_parsing_of_sequence_value_from_an_argument_with_one_token()
             {
                 var argument = new Argument<IEnumerable<int>>(result => result.Tokens.Single().Value.Split(',').Select(int.Parse));
 
-                argument.Parse("1,2,3")
+                new RootCommand { argument }.Parse("1,2,3")
                         .GetValue(argument)
                         .Should()
                         .BeEquivalentTo(new[] { 1, 2, 3 });
@@ -208,7 +208,7 @@ public void custom_parsing_of_sequence_value_from_an_argument_with_multiple_toke
                     return result.Tokens.Select(t => int.Parse(t.Value)).ToArray();
                 });
 
-                argument.Parse("1 2 3")
+                new RootCommand { argument }.Parse("1 2 3")
                         .GetValue(argument)
                         .Should()
                         .BeEquivalentTo(new[] { 1, 2, 3 });
@@ -222,7 +222,7 @@ public void custom_parsing_of_scalar_value_from_an_argument_with_multiple_tokens
                     Arity = ArgumentArity.ZeroOrMore
                 };
 
-                argument.Parse("1 2 3")
+                new RootCommand { argument }.Parse("1 2 3")
                         .GetValue(argument)
                         .Should()
                         .Be(6);
@@ -244,7 +244,8 @@ public void Option_ArgumentResult_Parent_is_set_correctly_when_token_is_implicit
                         }, isDefault: true)
                 };
 
-                command.Parse("");
+                CommandLineConfiguration simpleConfig = new (command);
+                command.Parse("", simpleConfig);
 
                 argumentResult
                     .Parent
@@ -375,7 +376,7 @@ public void Default_value_and_custom_argument_parser_can_be_used_together()
                 var argument = new Argument<int>(_ => 789, true);
                 argument.SetDefaultValue(123);
 
-                var result = argument.Parse("");
+                var result = new RootCommand { argument }.Parse("");
 
                 result.GetValue(argument)
                       .Should()
@@ -653,7 +654,7 @@ public void OnlyTake_throws_when_called_with_a_negative_value()
                         return null;
                     });
 
-                 argument.Invoking(a => a.Parse("1 2 3"))
+                 argument.Invoking(a => new RootCommand { a }.Parse("1 2 3"))
                          .Should()
                          .Throw<ArgumentOutOfRangeException>()
                          .Which
@@ -675,7 +676,7 @@ public void OnlyTake_throws_when_called_twice()
                         return null;
                     });
 
-                 argument.Invoking(a => a.Parse("1 2 3"))
+                 argument.Invoking(a => new RootCommand { a }.Parse("1 2 3"))
                          .Should()
                          .Throw<InvalidOperationException>()
                          .Which
diff --git a/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs b/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs
index 5b421460a9..beb956865d 100644
--- a/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs
+++ b/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs
@@ -293,10 +293,7 @@ public async Task When_User_Requests_Cancellation_Its_Reflected_By_The_Token_Pas
 
             using CancellationTokenSource cts = new ();
 
-            Parser parser = new CommandLineBuilder(new RootCommand { command })
-                .Build();
-
-            Task<int> invokeResult = parser.InvokeAsync("the-command", null, cts.Token);
+            Task<int> invokeResult = command.InvokeAsync("the-command", null, cts.Token);
 
             cts.Cancel();
 
diff --git a/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs b/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
index 419d8b2fb9..c3ce14de47 100644
--- a/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
+++ b/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
@@ -20,7 +20,7 @@ public void Option_argument_of_FileInfo_can_be_bound_without_custom_conversion_l
             var option = new Option<FileInfo>("--file");
 
             var file = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "the-file.txt"));
-            var result = option.Parse($"--file {file.FullName}");
+            var result = new RootCommand { option }.Parse($"--file {file.FullName}");
 
             result.GetValue(option)
                   .Name
@@ -70,7 +70,7 @@ public void Command_argument_of_FileInfo_returns_null_when_argument_is_not_provi
         public void Argument_of_FileInfo_that_is_empty_results_in_an_informative_error()
         {
             var option = new Option<FileInfo>("--file");
-            var result = option.Parse(new string[] { "--file", "" });
+            var result = new RootCommand { option }.Parse(new string[] { "--file", "" });
 
             result.Errors
                   .Should()
@@ -88,7 +88,7 @@ public void Argument_of_array_of_FileInfo_can_be_called_without_custom_conversio
 
             var file1 = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "file1.txt"));
             var file2 = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "file2.txt"));
-            var result = option.Parse($"--file {file1.FullName} --file {file2.FullName}");
+            var result = new RootCommand { option }.Parse($"--file {file1.FullName} --file {file2.FullName}");
 
             result.GetValue(option)
                   .Select(fi => fi.Name)
@@ -231,7 +231,7 @@ public void Nullable_bool_parses_as_null_when_the_option_has_not_been_applied()
         {
             var option = new Option<bool?>("-x");
 
-            option
+            new RootCommand { option }
                 .Parse("")
                 .GetValue(option)
                 .Should()
@@ -431,7 +431,7 @@ public void Values_can_be_correctly_converted_to_DateTime_without_the_parser_spe
             var option = new Option<DateTime>("-x");
 
             var dateString = "2022-02-06T01:46:03.0000000-08:00";
-            var value = option.Parse($"-x {dateString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {dateString}").GetValue(option);
 
             value.Should().Be(DateTime.Parse(dateString));
         }
@@ -443,7 +443,7 @@ public void Values_can_be_correctly_converted_to_nullable_DateTime_without_the_p
             var option = new Option<DateTime?>("-x");
 
             var dateString = "2022-02-06T01:46:03.0000000-08:00";
-            var value = option.Parse($"-x {dateString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {dateString}").GetValue(option);
 
             value.Should().Be(DateTime.Parse(dateString));
         }
@@ -454,7 +454,7 @@ public void Values_can_be_correctly_converted_to_DateTimeOffset_without_the_pars
             var option = new Option<DateTimeOffset>("-x");
 
             var dateString = "2022-02-06T09:52:54.5275055-08:00";
-            var value = option.Parse($"-x {dateString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {dateString}").GetValue(option);
 
             value.Should().Be(DateTime.Parse(dateString));
         }
@@ -465,7 +465,7 @@ public void Values_can_be_correctly_converted_to_nullable_DateTimeOffset_without
             var option = new Option<DateTimeOffset?>("-x");
 
             var dateString = "2022-02-06T09:52:54.5275055-08:00";
-            var value = option.Parse($"-x {dateString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {dateString}").GetValue(option);
 
             value.Should().Be(DateTime.Parse(dateString));
         }
@@ -475,7 +475,7 @@ public void Values_can_be_correctly_converted_to_decimal_without_the_parser_spec
         {
             var option = new Option<decimal>("-x");
 
-            var result = option.Parse("-x 123.456");
+            var result = new RootCommand { option }.Parse("-x 123.456");
 
             var value = result.GetValue(option);
 
@@ -487,7 +487,7 @@ public void Values_can_be_correctly_converted_to_nullable_decimal_without_the_pa
         {
             var option = new Option<decimal?>("-x");
 
-            var value = option.Parse("-x 123.456").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123.456").GetValue(option);
 
             value.Should().Be(123.456m);
         }
@@ -497,7 +497,7 @@ public void Values_can_be_correctly_converted_to_double_without_the_parser_speci
         {
             var option = new Option<double>("-x");
 
-            var value = option.Parse("-x 123.456").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123.456").GetValue(option);
 
             value.Should().Be(123.456d);
         }
@@ -507,7 +507,7 @@ public void Values_can_be_correctly_converted_to_nullable_double_without_the_par
         {
             var option = new Option<double?>("-x");
 
-            var value = option.Parse("-x 123.456").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123.456").GetValue(option);
 
             value.Should().Be(123.456d);
         }
@@ -517,7 +517,7 @@ public void Values_can_be_correctly_converted_to_float_without_the_parser_specif
         {
             var option = new Option<float>("-x");
 
-            var value = option.Parse("-x 123.456").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123.456").GetValue(option);
 
             value.Should().Be(123.456f);
         }
@@ -527,7 +527,7 @@ public void Values_can_be_correctly_converted_to_nullable_float_without_the_pars
         {
             var option = new Option<float?>("-x");
 
-            var value = option.Parse("-x 123.456").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123.456").GetValue(option);
 
             value.Should().Be(123.456f);
         }
@@ -538,7 +538,7 @@ public void Values_can_be_correctly_converted_to_Guid_without_the_parser_specify
             var guidString = "75517282-018F-46BB-B15F-1D8DBFE23F6E";
             var option = new Option<Guid>("-x");
 
-            var value = option.Parse($"-x {guidString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {guidString}").GetValue(option);
 
             value.Should().Be(Guid.Parse(guidString));
         }
@@ -549,7 +549,7 @@ public void Values_can_be_correctly_converted_to_nullable_Guid_without_the_parse
             var guidString = "75517282-018F-46BB-B15F-1D8DBFE23F6E";
             var option = new Option<Guid?>("-x");
 
-            var value = option.Parse($"-x {guidString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {guidString}").GetValue(option);
 
             value.Should().Be(Guid.Parse(guidString));
         }
@@ -560,7 +560,7 @@ public void Values_can_be_correctly_converted_to_TimeSpan_without_the_parser_spe
             var timeSpanString = "30";
             var option = new Option<TimeSpan>("-x");
 
-            var value = option.Parse($"-x {timeSpanString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {timeSpanString}").GetValue(option);
 
             value.Should().Be(TimeSpan.Parse(timeSpanString));
         }
@@ -571,7 +571,7 @@ public void Values_can_be_correctly_converted_to_nullable_TimeSpan_without_the_p
             var timeSpanString = "30";
             var option = new Option<TimeSpan?>("-x");
 
-            var value = option.Parse($"-x {timeSpanString}").GetValue(option);
+            var value = new RootCommand { option }.Parse($"-x {timeSpanString}").GetValue(option);
 
             value.Should().Be(TimeSpan.Parse(timeSpanString));
         }
@@ -581,7 +581,7 @@ public void Values_can_be_correctly_converted_to_Uri_without_the_parser_specifyi
         {
             var option = new Option<Uri>("-x");
 
-            var value = option.Parse("-x http://example.com").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x http://example.com").GetValue(option);
 
             value.Should().BeEquivalentTo(new Uri("http://example.com"));
         }
@@ -591,8 +591,8 @@ public void Options_with_arguments_specified_can_be_correctly_converted_to_bool_
         {
             var option = new Option<bool>("-x");
 
-            option.Parse("-x false").GetValue(option).Should().BeFalse();
-            option.Parse("-x true").GetValue(option).Should().BeTrue();
+            new RootCommand { option }.Parse("-x false").GetValue(option).Should().BeFalse();
+            new RootCommand { option }.Parse("-x true").GetValue(option).Should().BeTrue();
         }
 
         [Fact]
@@ -600,7 +600,7 @@ public void Values_can_be_correctly_converted_to_long_without_the_parser_specify
         {
             var option = new Option<long>("-x");
 
-            var value = option.Parse("-x 123456790").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123456790").GetValue(option);
 
             value.Should().Be(123456790L);
         }
@@ -610,7 +610,7 @@ public void Values_can_be_correctly_converted_to_nullable_long_without_the_parse
         {
             var option = new Option<long?>("-x");
 
-            var value = option.Parse("-x 1234567890").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1234567890").GetValue(option);
 
             value.Should().Be(1234567890L);
         }
@@ -620,7 +620,7 @@ public void Values_can_be_correctly_converted_to_short_without_the_parser_specif
         {
             var option = new Option<short>("-s");
 
-            var value = option.Parse("-s 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-s 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -630,7 +630,7 @@ public void Values_can_be_correctly_converted_to_nullable_short_without_the_pars
         {
             var option = new Option<short?>("-s");
 
-            var value = option.Parse("-s 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-s 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -640,7 +640,7 @@ public void Values_can_be_correctly_converted_to_ulong_without_the_parser_specif
         {
             var option = new Option<ulong>("-x");
 
-            var value = option.Parse("-x 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -650,7 +650,7 @@ public void Values_can_be_correctly_converted_to_nullable_ulong_without_the_pars
         {
             var option = new Option<ulong?>("-x");
 
-            var value = option.Parse("-x 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -660,7 +660,7 @@ public void Values_can_be_correctly_converted_to_ushort_without_the_parser_speci
         {
             var option = new Option<ushort>("-x");
 
-            var value = option.Parse("-x 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -670,7 +670,7 @@ public void Values_can_be_correctly_converted_to_nullable_ushort_without_the_par
         {
             var option = new Option<ushort?>("-x");
 
-            var value = option.Parse("-x 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -680,7 +680,7 @@ public void Values_can_be_correctly_converted_to_sbyte_without_the_parser_specif
         {
             var option = new Option<sbyte>("-us");
 
-            var value = option.Parse("-us 123").GetValue(option);
+            var value = new RootCommand { option }.Parse("-us 123").GetValue(option);
 
             value.Should().Be(123);
         }
@@ -690,7 +690,7 @@ public void Values_can_be_correctly_converted_to_nullable_sbyte_without_the_pars
         {
             var option = new Option<sbyte?>("-x");
 
-            var value = option.Parse("-x 123").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123").GetValue(option);
 
             value.Should().Be(123);
         }
@@ -700,7 +700,7 @@ public void Values_can_be_correctly_converted_to_ipaddress_without_the_parser_sp
         {
             var option = new Option<IPAddress>("-us");
 
-            var value = option.Parse("-us 1.2.3.4").GetValue(option);
+            var value = new RootCommand { option }.Parse("-us 1.2.3.4").GetValue(option);
 
             value.Should().Be(IPAddress.Parse("1.2.3.4"));
         }
@@ -711,7 +711,7 @@ public void Values_can_be_correctly_converted_to_ipendpoint_without_the_parser_s
         {
             var option = new Option<IPEndPoint>("-us");
 
-            var value = option.Parse("-us 1.2.3.4:56").GetValue(option);
+            var value = new RootCommand { option }.Parse("-us 1.2.3.4:56").GetValue(option);
 
             value.Should().Be(IPEndPoint.Parse("1.2.3.4:56"));
         }
@@ -723,7 +723,7 @@ public void Values_can_be_correctly_converted_to_dateonly_without_the_parser_spe
         {
             var option = new Option<DateOnly>("-us");
 
-            var value = option.Parse("-us 2022-03-02").GetValue(option);
+            var value = new RootCommand { option }.Parse("-us 2022-03-02").GetValue(option);
 
             value.Should().Be(DateOnly.Parse("2022-03-02"));
         }
@@ -733,7 +733,7 @@ public void Values_can_be_correctly_converted_to_nullable_dateonly_without_the_p
         {
             var option = new Option<DateOnly?>("-x");
 
-            var value = option.Parse("-x 2022-03-02").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 2022-03-02").GetValue(option);
 
             value.Should().Be(DateOnly.Parse("2022-03-02"));
         }
@@ -743,7 +743,7 @@ public void Values_can_be_correctly_converted_to_timeonly_without_the_parser_spe
         {
             var option = new Option<TimeOnly>("-us");
 
-            var value = option.Parse("-us 12:34:56").GetValue(option);
+            var value = new RootCommand { option }.Parse("-us 12:34:56").GetValue(option);
 
             value.Should().Be(TimeOnly.Parse("12:34:56"));
         }
@@ -753,7 +753,7 @@ public void Values_can_be_correctly_converted_to_nullable_timeonly_without_the_p
         {
             var option = new Option<TimeOnly?>("-x");
 
-            var value = option.Parse("-x 12:34:56").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 12:34:56").GetValue(option);
 
             value.Should().Be(TimeOnly.Parse("12:34:56"));
         }
@@ -764,7 +764,7 @@ public void Values_can_be_correctly_converted_to_byte_without_the_parser_specify
         {
             var option = new Option<byte>("-us");
 
-            var value = option.Parse("-us 123").GetValue(option);
+            var value = new RootCommand { option }.Parse("-us 123").GetValue(option);
 
             value.Should().Be(123);
         }
@@ -774,7 +774,7 @@ public void Values_can_be_correctly_converted_to_nullable_byte_without_the_parse
         {
             var option = new Option<byte?>("-x");
 
-            var value = option.Parse("-x 123").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 123").GetValue(option);
 
             value.Should().Be(123);
         }
@@ -784,7 +784,7 @@ public void Values_can_be_correctly_converted_to_uint_without_the_parser_specify
         {
             var option = new Option<uint>("-us");
 
-            var value = option.Parse("-us 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-us 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -794,7 +794,7 @@ public void Values_can_be_correctly_converted_to_nullable_uint_without_the_parse
         {
             var option = new Option<uint?>("-x");
 
-            var value = option.Parse("-x 1234").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1234").GetValue(option);
 
             value.Should().Be(1234);
         }
@@ -804,7 +804,7 @@ public void Values_can_be_correctly_converted_to_array_of_int_without_the_parser
         {
             var option = new Option<int[]>("-x");
 
-            var value = option.Parse("-x 1 -x 2 -x 3").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1 -x 2 -x 3").GetValue(option);
 
             value.Should().BeEquivalentTo(1, 2, 3);
         }
@@ -855,7 +855,7 @@ public void Values_can_be_correctly_converted_to_List_of_int_without_the_parser_
         {
             var option = new Option<List<int>>("-x");
 
-            var value = option.Parse("-x 1 -x 2 -x 3").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1 -x 2 -x 3").GetValue(option);
 
             value.Should().BeEquivalentTo(1, 2, 3);
         }
@@ -865,7 +865,7 @@ public void Values_can_be_correctly_converted_to_IEnumerable_of_int_without_the_
         {
             var option = new Option<IEnumerable<int>>("-x");
 
-            var value = option.Parse("-x 1 -x 2 -x 3").GetValue(option);
+            var value = new RootCommand { option }.Parse("-x 1 -x 2 -x 3").GetValue(option);
 
             value.Should().BeEquivalentTo(1, 2, 3);
         }
@@ -875,7 +875,7 @@ public void Enum_values_can_be_correctly_converted_based_on_enum_value_name_with
         {
             var option = new Option<DayOfWeek>("-x");
 
-            var parseResult = option.Parse("-x Monday");
+            var parseResult = new RootCommand { option }.Parse("-x Monday");
 
             var value = parseResult.GetValue(option);
 
@@ -887,7 +887,7 @@ public void Nullable_enum_values_can_be_correctly_converted_based_on_enum_value_
         {
             var option = new Option<DayOfWeek?>("-x");
 
-            var parseResult = option.Parse("-x Monday");
+            var parseResult = new RootCommand { option }.Parse("-x Monday");
 
             var value = parseResult.GetValue(option);
 
@@ -899,7 +899,7 @@ public void Enum_values_that_cannot_be_parsed_result_in_an_informative_error()
         {
             var option = new Option<DayOfWeek>("-x");
 
-            var value = option.Parse("-x Notaday");
+            var value = new RootCommand { option }.Parse("-x Notaday");
 
             value.Errors
                  .Should()
@@ -915,7 +915,7 @@ public void When_getting_a_single_value_and_specifying_a_conversion_type_that_is
         {
             var option = new Option<int>("-x");
 
-            var result = option.Parse("-x not-an-int");
+            var result = new RootCommand { option }.Parse("-x not-an-int");
 
             Action getValue = () => result.GetValue(option);
 
@@ -932,7 +932,7 @@ public void When_getting_an_array_of_values_and_specifying_a_conversion_type_tha
         {
             var option = new Option<int[]>("-x");
 
-            var result = option.Parse("-x not-an-int -x 2");
+            var result = new RootCommand { option }.Parse("-x not-an-int -x 2");
 
             Action getValue = () => result.GetValue(option);
 
@@ -987,7 +987,7 @@ public void Sequence_type_defaults_to_empty_when_not_specified(Type sequenceType
 
         private void AssertParsedValueIsEmpty<T>(Argument<T> argument) where T : IEnumerable
         {
-            var result = argument.Parse("");
+            var result = new RootCommand { argument }.Parse("");
 
             result.GetValue(argument)
                   .Should()
diff --git a/src/System.CommandLine.Tests/CommandExtensionsTests.cs b/src/System.CommandLine.Tests/CommandExtensionsTests.cs
index 1c74c5df8b..f9424eeca9 100644
--- a/src/System.CommandLine.Tests/CommandExtensionsTests.cs
+++ b/src/System.CommandLine.Tests/CommandExtensionsTests.cs
@@ -79,39 +79,5 @@ public async Task Implicit_parsers_for_Parse_and_Invoke_do_not_affect_one_anothe
             
             console.Should().ShowHelp();
         }
-
-        [Fact]
-        public void Invoke_extension_method_reuses_implicit_parser_instance()
-        {
-            List<Parser> parsers = new();
-            var command = new Command("x");
-
-            command.SetHandler(context => parsers.Add(context.ParseResult.Parser));
-
-            command.Invoke("");
-            command.Invoke("");
-
-            var parser1 = parsers[0];
-            var parser2 = parsers[1];
-
-            parser1.Should().BeSameAs(parser2);
-        }
-
-        [Fact]
-        public void Parse_and_Invoke_extension_methods_use_different_implicit_parsers()
-        {
-            var command = new Command("x");
-
-            Parser implicitParserForInvoking = null;
-            Parser implicitParserForParsing = null;
-
-            command.SetHandler(context => implicitParserForInvoking = context.ParseResult.Parser);
-
-            command.Invoke("");
-
-            implicitParserForParsing = command.Parse("").Parser;
-
-            implicitParserForInvoking.Should().NotBeSameAs(implicitParserForParsing);
-        }
     }
 }
\ No newline at end of file
diff --git a/src/System.CommandLine.Tests/CommandTests.cs b/src/System.CommandLine.Tests/CommandTests.cs
index ff846e91ab..0766e5d5a6 100644
--- a/src/System.CommandLine.Tests/CommandTests.cs
+++ b/src/System.CommandLine.Tests/CommandTests.cs
@@ -10,24 +10,23 @@ namespace System.CommandLine.Tests
 {
     public class CommandTests : SymbolTests
     {
-        private readonly Parser _parser;
+        private readonly Command _outerCommand;
 
         public CommandTests()
         {
-            _parser = new Parser(
-                new Command("outer")
+            _outerCommand = new Command("outer")
+            {
+                new Command("inner")
                 {
-                    new Command("inner")
-                    {
-                        new Option<string>("--option")
-                    }
-                });
+                    new Option<string>("--option")
+                }
+            };
         }
 
         [Fact]
         public void Outer_command_is_identified_correctly_by_RootCommand()
         {
-            var result = _parser.Parse("outer inner --option argument1");
+            var result = _outerCommand.Parse("outer inner --option argument1");
 
             result
                 .RootCommandResult
@@ -40,7 +39,7 @@ public void Outer_command_is_identified_correctly_by_RootCommand()
         [Fact]
         public void Outer_command_is_identified_correctly_by_Parent_property()
         {
-            var result = _parser.Parse("outer inner --option argument1");
+            var result = _outerCommand.Parse("outer inner --option argument1");
 
             result
                 .CommandResult
@@ -57,7 +56,7 @@ public void Outer_command_is_identified_correctly_by_Parent_property()
         [Fact]
         public void Inner_command_is_identified_correctly()
         {
-            var result = _parser.Parse("outer inner --option argument1");
+            var result = _outerCommand.Parse("outer inner --option argument1");
 
             result.CommandResult
                   .Should()
@@ -72,7 +71,7 @@ public void Inner_command_is_identified_correctly()
         [Fact]
         public void Inner_command_option_is_identified_correctly()
         {
-            var result = _parser.Parse("outer inner --option argument1");
+            var result = _outerCommand.Parse("outer inner --option argument1");
 
             result.CommandResult
                   .Children
@@ -89,7 +88,7 @@ public void Inner_command_option_is_identified_correctly()
         [Fact]
         public void Inner_command_option_argument_is_identified_correctly()
         {
-            var result = _parser.Parse("outer inner --option argument1");
+            var result = _outerCommand.Parse("outer inner --option argument1");
 
             result.CommandResult
                   .Children
@@ -113,9 +112,7 @@ public void Commands_at_multiple_levels_can_have_their_own_arguments()
                     new Argument<string[]>()
                 });
 
-            var parser = new Parser(outer);
-
-            var result = parser.Parse("outer arg1 inner arg2 arg3");
+            var result = outer.Parse("outer arg1 inner arg2 arg3");
 
             result.CommandResult
                   .Parent
diff --git a/src/System.CommandLine.Tests/CompletionContextTests.cs b/src/System.CommandLine.Tests/CompletionContextTests.cs
index 554bfe1d73..f2c36fb931 100644
--- a/src/System.CommandLine.Tests/CompletionContextTests.cs
+++ b/src/System.CommandLine.Tests/CompletionContextTests.cs
@@ -64,7 +64,7 @@ public void CommandLineText_is_unavailable_when_string_array_is_parsed()
                 }
             };
 
-            var parseResult = command.Parse("verb", "-x", "123");
+            var parseResult = command.Parse(new[] { "verb", "-x", "123" });
 
             parseResult.GetCompletionContext()
                        .Should()
@@ -137,7 +137,7 @@ public void When_position_is_unspecified_in_array_command_line_and_final_token_i
                 new Option<string>("--option2")
             };
 
-            string textToMatch = command.Parse("the-command", "opt")
+            string textToMatch = command.Parse(new[] { "the-command", "opt" })
                                         .GetCompletionContext()
                                         .WordToComplete;
 
@@ -169,7 +169,7 @@ public void When_position_is_unspecified_in_array_command_line_and_final_token_m
                 new Option<string>("--option2")
             };
 
-            string textToMatch = command.Parse("the-command", "--option1")
+            string textToMatch = command.Parse(new[] { "the-command", "--option1" })
                                         .GetCompletionContext()
                                         .WordToComplete;
 
@@ -189,7 +189,7 @@ public void When_position_is_unspecified_in_array_command_line_and_final_token_m
                 new Argument<string>()
             };
 
-            string textToMatch = command.Parse("the-command", "--option1", "a")
+            string textToMatch = command.Parse(new[] { "the-command", "--option1", "a" })
                                         .GetCompletionContext()
                                         .WordToComplete;
 
diff --git a/src/System.CommandLine.Tests/CompletionTests.cs b/src/System.CommandLine.Tests/CompletionTests.cs
index 29f9d2aaae..dd32982ab1 100644
--- a/src/System.CommandLine.Tests/CompletionTests.cs
+++ b/src/System.CommandLine.Tests/CompletionTests.cs
@@ -182,7 +182,8 @@ public void Command_GetCompletions_with_text_to_match_orders_by_match_position_t
                 new Command("andmyothersubcommand"),
             };
 
-            var completions = command.Parse("my").GetCompletions();
+            CommandLineConfiguration simpleConfig = new (command);
+            var completions = command.Parse("my", simpleConfig).GetCompletions();
 
             completions
                 .Select(item => item.Label)
@@ -193,14 +194,15 @@ public void Command_GetCompletions_with_text_to_match_orders_by_match_position_t
         [Fact]
         public void When_an_option_has_a_default_value_it_will_still_be_suggested()
         {
-            var parser = new RootCommand
+            var command = new RootCommand
             {
                 new Option<string>("--apple", defaultValueFactory: () => "cortland"),
                 new Option<string>("--banana"),
                 new Option<string>("--cherry")
             };
 
-            var result = parser.Parse("");
+            CommandLineConfiguration simpleConfig = new (command);
+            var result = command.Parse("", simpleConfig);
 
             _output.WriteLine(result.ToString());
 
@@ -224,14 +226,14 @@ public void Command_GetCompletions_can_access_ParseResult()
                 return !string.IsNullOrWhiteSpace(opt1Value) ? new[] { opt1Value } : Array.Empty<string>();
             });
 
-            var parser = new Parser(
-                new RootCommand
-                {
-                    originOption,
-                    cloneOption
-                });
+            RootCommand rootCommand = new RootCommand
+            {
+                originOption,
+                cloneOption
+            };
 
-            var result = parser.Parse("--origin test --clone ");
+            CommandLineConfiguration simpleConfig = new (rootCommand);
+            var result = rootCommand.Parse("--origin test --clone ", simpleConfig);
 
             _output.WriteLine(result.ToString());
 
@@ -244,15 +246,16 @@ public void Command_GetCompletions_can_access_ParseResult()
         [Fact]
         public void When_one_option_has_been_specified_then_it_and_its_siblings_will_still_be_suggested()
         {
-            var parser = new Command("command")
-                         {
-                             new Option<string>("--apple"),
-                             new Option<string>("--banana"),
-                             new Option<string>("--cherry")
-                         };
+            var command = new Command("command")
+            {
+                new Option<string>("--apple"),
+                new Option<string>("--banana"),
+                new Option<string>("--cherry")
+            };
 
             var commandLine = "--apple grannysmith";
-            var result = parser.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (command);
+            var result = command.Parse(commandLine, simpleConfig);
 
             result.GetCompletions(commandLine.Length + 1)
                   .Select(item => item.Label)
@@ -279,8 +282,9 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_commands_will_
                     new Option<string>("--rainier")
                 }
             };
+            CommandLineConfiguration simpleConfig = new (rootCommand);
 
-            var result = rootCommand.Parse("cherry ");
+            var result = rootCommand.Parse("cherry ", simpleConfig);
 
             result.GetCompletions()
                   .Should()
@@ -307,8 +311,9 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_commands_alias
                 apple,
                 banana
             };
+            CommandLineConfiguration simpleConfig = new (rootCommand);
 
-            var result = rootCommand.Parse("banana ");
+            var result = rootCommand.Parse("banana ", simpleConfig);
 
             result.GetCompletions()
                   .Select(item => item.Label)
@@ -326,7 +331,8 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_options_will_n
             };
 
             var commandLine = "child";
-            var parseResult = command.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (command);
+            var parseResult = command.Parse(commandLine, simpleConfig);
 
             parseResult
                 .GetCompletions(commandLine.Length + 1)
@@ -346,7 +352,8 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_options_with_a
             };
 
             var commandLine = "--parent-option 123 child";
-            var parseResult = command.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (command);
+            var parseResult = command.Parse(commandLine, simpleConfig);
 
             parseResult
                 .GetCompletions(commandLine.Length + 1)
@@ -367,7 +374,8 @@ public void When_a_subcommand_has_been_specified_then_its_child_options_will_be_
             };
 
             var commandLine = "child ";
-            var parseResult = command.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (command);
+            var parseResult = command.Parse(commandLine, simpleConfig);
 
             parseResult
                 .GetCompletions(commandLine.Length + 1)
@@ -396,7 +404,8 @@ public void When_a_subcommand_with_subcommands_has_been_specified_then_its_sibli
             };
 
             var commandLine = "cherry";
-            var result = rootCommand.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (rootCommand);
+            var result = rootCommand.Parse(commandLine, simpleConfig);
 
             result.GetCompletions(commandLine.Length + 1)
                   .Select(item => item.Label)
@@ -415,7 +424,8 @@ public void When_one_option_has_been_partially_specified_then_nonmatching_siblin
             };
 
             var input = "a";
-            var result = command.Parse(input);
+            CommandLineConfiguration simpleConfig = new (command);
+            var result = command.Parse(input, simpleConfig);
 
             result.GetCompletions(input.Length)
                   .Select(item => item.Label)
@@ -436,7 +446,8 @@ public void An_option_can_be_hidden_from_completions_by_setting_IsHidden_to_true
                 new Option<string>("-n", "Not hidden")
             };
 
-            var completions = command.Parse("the-command ").GetCompletions();
+            CommandLineConfiguration simpleConfig = new (command);
+            var completions = command.Parse("the-command ", simpleConfig).GetCompletions();
 
             completions.Select(item => item.Label).Should().NotContain("--hide-me");
         }
@@ -444,14 +455,15 @@ public void An_option_can_be_hidden_from_completions_by_setting_IsHidden_to_true
         [Fact]
         public void Parser_options_can_supply_context_sensitive_matches()
         {
-            var parser = new RootCommand
+            var command = new RootCommand
             {
                 CreateOptionWithAcceptOnlyFromAmong(name: "--bread", "wheat", "sourdough", "rye"),
                 CreateOptionWithAcceptOnlyFromAmong(name: "--cheese", "provolone", "cheddar", "cream cheese")
             };
 
             var commandLine = "--bread";
-            var result = parser.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (command);
+            var result = command.Parse(commandLine, simpleConfig);
 
             result.GetCompletions(commandLine.Length + 1)
                   .Select(item => item.Label)
@@ -459,7 +471,7 @@ public void Parser_options_can_supply_context_sensitive_matches()
                   .BeEquivalentTo("rye", "sourdough", "wheat");
 
             commandLine = "--bread wheat --cheese ";
-            result = parser.Parse(commandLine);
+            result = command.Parse(commandLine, simpleConfig);
 
             result.GetCompletions(commandLine.Length + 1)
                   .Select(item => item.Label)
@@ -478,7 +490,8 @@ public void Subcommand_names_are_available_as_suggestions()
             };
 
             var commandLine = "test";
-            command.Parse(commandLine)
+            CommandLineConfiguration simpleConfig = new (command);
+            command.Parse(commandLine, simpleConfig)
                    .GetCompletions(commandLine.Length + 1)
                    .Select(item => item.Label)
                    .Should()
@@ -496,8 +509,8 @@ public void Both_subcommands_and_options_are_available_as_suggestions()
             };
 
             var commandLine = "test";
-
-            command.Parse(commandLine)
+            CommandLineConfiguration simpleConfig = new (command);
+            command.Parse(commandLine, simpleConfig)
                    .GetCompletions(commandLine.Length + 1)
                    .Select(item => item.Label)
                    .Should()
@@ -516,9 +529,8 @@ public void Option_GetCompletions_are_not_provided_without_matching_prefix(strin
                 new Option<string>("--three")
             };
 
-            var parser = new Parser(command);
-
-            ParseResult result = parser.Parse(input);
+            CommandLineConfiguration simpleConfig = new (command);
+            ParseResult result = command.Parse(input, simpleConfig);
             result.GetCompletions()
                   .Select(item => item.Label)
                   .Should()
@@ -528,16 +540,16 @@ public void Option_GetCompletions_are_not_provided_without_matching_prefix(strin
         [Fact]
         public void Option_GetCompletions_can_be_based_on_the_proximate_option()
         {
-            var parser = new Parser(
-                new Command("outer")
-                {
-                    new Option<string>("--one"),
-                    new Option<string>("--two"),
-                    new Option<string>("--three")
-                });
+            Command outer = new Command("outer")
+            {
+                new Option<string>("--one"),
+                new Option<string>("--two"),
+                new Option<string>("--three")
+            };
 
             var commandLine = "outer";
-            ParseResult result = parser.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (outer);
+            ParseResult result = outer.Parse(commandLine, simpleConfig);
 
             result.GetCompletions(commandLine.Length + 1)
                   .Select(item => item.Label)
@@ -548,15 +560,15 @@ public void Option_GetCompletions_can_be_based_on_the_proximate_option()
         [Fact]
         public void Argument_completions_can_be_based_on_the_proximate_option()
         {
-            var parser = new Parser(
-                new Command("outer")
-                {
-                    CreateOptionWithAcceptOnlyFromAmong(name: "--one", "one-a", "one-b"),
-                    CreateOptionWithAcceptOnlyFromAmong(name: "--two", "two-a", "two-b")
-                });
+            var outer = new Command("outer")
+            {
+                CreateOptionWithAcceptOnlyFromAmong(name: "--one", "one-a", "one-b"),
+                CreateOptionWithAcceptOnlyFromAmong(name: "--two", "two-a", "two-b")
+            };
 
             var commandLine = "outer --two";
-            ParseResult result = parser.Parse(commandLine);
+            CommandLineConfiguration simpleConfig = new (outer);
+            ParseResult result = outer.Parse(commandLine, simpleConfig);
 
             result.GetCompletions(commandLine.Length + 1)
                   .Select(item => item.Label)
@@ -567,15 +579,15 @@ public void Argument_completions_can_be_based_on_the_proximate_option()
         [Fact]
         public void Option_GetCompletions_can_be_based_on_the_proximate_option_and_partial_input()
         {
-            var parser = new Parser(
-                new Command("outer")
-                {
-                    new Command("one", "Command one"),
-                    new Command("two", "Command two"),
-                    new Command("three", "Command three")
-                });
+            var outer = new Command("outer")
+            {
+                new Command("one", "Command one"),
+                new Command("two", "Command two"),
+                new Command("three", "Command three")
+            };
 
-            ParseResult result = parser.Parse("outer o");
+            CommandLineConfiguration simpleConfig = new (outer);
+            ParseResult result = outer.Parse("outer o", simpleConfig);
 
             result.GetCompletions()
                   .Select(item => item.Label)
@@ -590,18 +602,19 @@ public void Completions_can_be_provided_in_the_absence_of_validation()
             option.CompletionSources.Add("vegetable", "mineral", "animal");
 
             var command = new Command("the-command")
-                {
-                    option
-                };
+            {
+                option
+            };
 
-            command.Parse("the-command -t m")
+            CommandLineConfiguration simpleConfig = new (command);
+            command.Parse("the-command -t m", simpleConfig)
                    .GetCompletions()
                    .Select(item => item.Label)
                    .Should()
                    .BeEquivalentTo("animal",
                                    "mineral");
 
-            command.Parse("the-command -t something-else")
+            command.Parse("the-command -t something-else", simpleConfig)
                    .Errors
                    .Should()
                    .BeEmpty();
@@ -658,13 +671,13 @@ public void When_caller_does_the_tokenizing_then_argument_completions_are_based_
                 CreateOptionWithAcceptOnlyFromAmong(name: "three", "three-a", "three-b", "three-c")
             };
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var configuration = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
                          .Build();
 
-            var result = parser.Parse("outer two b" );
+            var result = command.Parse("outer two b", configuration);
 
             result.GetCompletions()
                   .Select(item => item.Label)
@@ -753,8 +766,8 @@ public void When_parsing_from_text_if_the_proximate_option_is_completed_then_com
                 CreateOptionWithAcceptOnlyFromAmong(name: "--language", "C#"),
                 new Option<string>("--langVersion")
             };
-            var parser = new CommandLineBuilder(command).Build();
-            var completions = parser.Parse("--framework net7.0 --l").GetCompletions();
+            var configuration = new CommandLineBuilder(command).Build();
+            var completions = command.Parse("--framework net7.0 --l", configuration).GetCompletions();
 
             completions.Select(item => item.Label)
                        .Should()
@@ -770,8 +783,8 @@ public void When_parsing_from_array_if_the_proximate_option_is_completed_then_co
                 CreateOptionWithAcceptOnlyFromAmong(name: "--language", "C#"),
                 new Option<string>("--langVersion")
             };
-            var parser = new CommandLineBuilder(command).Build();
-            var completions = parser.Parse(new[]{"--framework","net7.0","--l"}).GetCompletions();
+            var configuration = new CommandLineBuilder(command).Build();
+            var completions = command.Parse(new[]{"--framework","net7.0","--l"}, configuration).GetCompletions();
 
             completions.Select(item => item.Label)
                        .Should()
@@ -805,7 +818,8 @@ public void Options_that_have_been_specified_to_their_maximum_arity_are_not_sugg
             };
 
             var commandLine = "--allows-one x";
-            var completions = command.Parse(commandLine).GetCompletions(commandLine.Length + 1);
+            CommandLineConfiguration simpleConfig = new (command);
+            var completions = command.Parse(commandLine, simpleConfig).GetCompletions(commandLine.Length + 1);
 
             completions.Select(item => item.Label)
                        .Should()
@@ -815,7 +829,7 @@ public void Options_that_have_been_specified_to_their_maximum_arity_are_not_sugg
         [Fact]
         public void When_current_symbol_is_an_option_that_requires_arguments_then_parent_symbol_completions_are_omitted()
         {
-            var parser = new CommandLineBuilder(new RootCommand
+            var configuration = new CommandLineBuilder(new RootCommand
                          {
                              new Option<string>("--allows-one"),
                              new Option<string[]>("--allows-many")
@@ -823,7 +837,7 @@ public void When_current_symbol_is_an_option_that_requires_arguments_then_parent
                          .UseSuggestDirective()
                          .Build();
 
-            var completions = parser.Parse("--allows-one ").GetCompletions();
+            var completions = configuration.RootCommand.Parse("--allows-one ", configuration).GetCompletions();
 
             completions.Should().BeEmpty();
         }
@@ -884,8 +898,8 @@ public void Default_completions_can_be_cleared_and_replaced()
             {
                 argument
             };
-
-            var completions = command.Parse("the-command s")
+            CommandLineConfiguration simpleConfig = new (command);
+            var completions = command.Parse("the-command s", simpleConfig)
                                      .GetCompletions();
 
             completions.Select(item => item.Label)
@@ -904,7 +918,8 @@ public void Default_completions_can_be_appended_to()
                 }
             };
 
-            var completions = command.Parse("the-command s")
+            CommandLineConfiguration simpleConfig = new (command);
+            var completions = command.Parse("the-command s", simpleConfig)
                                      .GetCompletions();
 
             completions
@@ -954,9 +969,11 @@ public void Completions_for_subcommands_provide_a_description()
         [Fact] // https://github.com/dotnet/command-line-api/issues/1629
         public void When_option_completions_are_available_then_they_are_suggested_when_a_validation_error_occurs()
         {
-            var option = new Option<DayOfWeek>("--day");
+            Option<DayOfWeek> option = new ("--day");
+            RootCommand rootCommand = new () { option };
+            CommandLineConfiguration simpleConfig = new (rootCommand);
 
-            var result = option.Parse("--day SleepyDay");
+            var result = rootCommand.Parse("--day SleepyDay", simpleConfig);
 
             result.Errors
                   .Should()
diff --git a/src/System.CommandLine.Tests/DirectiveTests.cs b/src/System.CommandLine.Tests/DirectiveTests.cs
index 0a6b5e8bf5..3b9ad10a0e 100644
--- a/src/System.CommandLine.Tests/DirectiveTests.cs
+++ b/src/System.CommandLine.Tests/DirectiveTests.cs
@@ -16,7 +16,7 @@ public void Directives_should_not_be_considered_as_unmatched_tokens()
         {
             var option = new Option<bool>("-y");
 
-            var result = option.Parse($"{RootCommand.ExecutableName} [parse] -y");
+            var result = new RootCommand { option }.Parse($"{RootCommand.ExecutableName} [parse] -y");
 
             result.UnmatchedTokens.Should().BeEmpty();
         }
@@ -26,7 +26,7 @@ public void Raw_tokens_still_hold_directives()
         {
             var option = new Option<bool>("-y");
 
-            var result = option.Parse("[parse] -y");
+            var result = new RootCommand { option }.Parse("[parse] -y");
 
             result.Directives.ContainsKey("parse").Should().BeTrue();
             result.Tokens.Should().Contain(t => t.Value == "[parse]");
@@ -37,7 +37,7 @@ public void Directives_should_parse_into_the_directives_collection()
         {
             var option = new Option<bool>("-y");
 
-            var result = option.Parse("[parse] -y");
+            var result = new RootCommand { option }.Parse("[parse] -y");
 
             result.Directives.ContainsKey("parse").Should().BeTrue();
         }
@@ -47,7 +47,7 @@ public void Multiple_directives_are_allowed()
         {
             var option = new Option<bool>("-y");
 
-            var result = option.Parse("[parse] [suggest] -y");
+            var result = new RootCommand { option }.Parse("[parse] [suggest] -y");
 
             result.Directives.ContainsKey("parse").Should().BeTrue();
             result.Directives.ContainsKey("suggest").Should().BeTrue();
@@ -58,7 +58,7 @@ public void Directives_must_be_the_first_argument()
         {
             var option = new Option<bool>("-y");
 
-            var result = option.Parse("-y [suggest]");
+            var result = new RootCommand { option }.Parse("-y [suggest]");
 
             result.Directives.Should().BeEmpty();
         }
@@ -74,7 +74,7 @@ public void Directives_can_have_a_value_which_is_everything_after_the_first_colo
         {
             var option = new Option<bool>("-y");
 
-            var result = option.Parse($"{directive} -y");
+            var result = new RootCommand { option }.Parse($"{directive} -y");
 
             result.Directives.TryGetValue(expectedKey, out var values).Should().BeTrue();
             values.Should().BeEquivalentTo(expectedValue);
@@ -85,7 +85,7 @@ public void Directives_without_a_value_specified_have_a_value_of_empty_string()
         {
             var option = new Option<bool>("-y");
 
-            var result = option.Parse("[parse] -y");
+            var result = new RootCommand { option }.Parse("[parse] -y");
 
             result.Directives.TryGetValue("parse", out var values).Should().BeTrue();
             values.Should().BeEmpty();
@@ -98,7 +98,7 @@ public void Directives_must_have_a_non_empty_key(string directive)
         {
             var option = new Option<bool>("-a");
 
-            var result = option.Parse($"{directive} -a");
+            var result = new RootCommand { option }.Parse($"{directive} -a");
 
             result.Directives.Should().BeEmpty();
             result.UnmatchedTokens.Should().Contain(directive);
@@ -112,7 +112,7 @@ public void Directives_cannot_contain_spaces(object value)
         {
             var option = new Option<bool>("-a");
 
-            var result = option.Parse($"{value} -a");
+            var result = new RootCommand { option }.Parse($"{value} -a");
 
             result.Directives.Should().BeEmpty();
         }
@@ -122,7 +122,7 @@ public void When_a_directive_is_specified_more_than_once_then_its_values_are_agg
         {
             var option = new Option<bool>("-a");
 
-            var result = option.Parse("[directive:one] [directive:two] -a");
+            var result = new RootCommand { option }.Parse("[directive:one] [directive:two] -a");
 
             result.Directives.TryGetValue("directive", out var values).Should().BeTrue();
             values.Should().BeEquivalentTo("one", "two");
@@ -141,15 +141,16 @@ public void Directive_count_is_based_on_distinct_instances_of_directive_name()
         [Fact]
         public void Directives_can_be_disabled()
         {
-            var parser = new Parser(
+            RootCommand rootCommand = new ()
+            {
+                new Argument<List<string>>()
+            };
+            var configuration =
                 new CommandLineConfiguration(
-                    new RootCommand
-                    {
-                        new Argument<List<string>>()
-                    },
-                    enableDirectives: false));
+                    rootCommand,
+                    enableDirectives: false);
 
-            var result = parser.Parse("[hello]");
+            var result = rootCommand.Parse("[hello]", configuration);
 
             result.Directives.Count().Should().Be(0);
             result.CommandResult
diff --git a/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs b/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs
index 3d0136037b..0ca5fa347b 100644
--- a/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs
+++ b/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs
@@ -25,11 +25,11 @@ public async Task Sets_environment_variable_to_value()
                 Environment.GetEnvironmentVariable(variable).Should().Be(value);
             });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                 .UseEnvironmentVariableDirective()
                 .Build();
 
-            await parser.InvokeAsync(new[] { $"[env:{variable}={value}]" });
+            await config.InvokeAsync(new[] { $"[env:{variable}={value}]" });
 
             asserted.Should().BeTrue();
         }
@@ -47,11 +47,11 @@ public async Task Trims_environment_variable_name()
                 Environment.GetEnvironmentVariable(variable).Should().Be(value);
             });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                 .UseEnvironmentVariableDirective()
                 .Build();
 
-            await parser.InvokeAsync(new[] { $"[env:     {variable}    ={value}]" });
+            await config.InvokeAsync(new[] { $"[env:     {variable}    ={value}]" });
 
             asserted.Should().BeTrue();
         }
@@ -69,11 +69,11 @@ public async Task Trims_environment_variable_value()
                 Environment.GetEnvironmentVariable(variable).Should().Be(value);
             });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                 .UseEnvironmentVariableDirective()
                 .Build();
 
-            await parser.InvokeAsync(new[] { $"[env:{variable}=    {value}     ]" });
+            await config.InvokeAsync(new[] { $"[env:{variable}=    {value}     ]" });
 
             asserted.Should().BeTrue();
         }
@@ -91,11 +91,11 @@ public async Task Sets_environment_variable_value_containing_equals_sign()
                 Environment.GetEnvironmentVariable(variable).Should().Be(value);
             });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                 .UseEnvironmentVariableDirective()
                 .Build();
 
-            await parser.InvokeAsync(new[] { $"[env:{variable}={value}]" });
+            await config.InvokeAsync(new[] { $"[env:{variable}={value}]" });
 
             asserted.Should().BeTrue();
         }
@@ -112,11 +112,11 @@ public async Task Ignores_environment_directive_without_equals_sign()
                 Environment.GetEnvironmentVariable(variable).Should().BeNull();
             });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                 .UseEnvironmentVariableDirective()
                 .Build();
 
-            await parser.InvokeAsync(new[] { $"[env:{variable}]" });
+            await config.InvokeAsync(new[] { $"[env:{variable}]" });
 
             asserted.Should().BeTrue();
         }
@@ -134,11 +134,11 @@ public static async Task Ignores_environment_directive_with_empty_variable_name(
                 env.Values.Cast<string>().Should().NotContain(value);
             });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                 .UseEnvironmentVariableDirective()
                 .Build();
 
-            await parser.InvokeAsync(new[] { $"[env:={value}]" });
+            await config.InvokeAsync(new[] { $"[env:={value}]" });
 
             asserted.Should().BeTrue();
         }
@@ -156,11 +156,11 @@ public static async Task Ignores_environment_directive_with_whitespace_variable_
                 env.Values.Cast<string>().Should().NotContain(value);
             });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                 .UseEnvironmentVariableDirective()
                 .Build();
 
-            await parser.InvokeAsync(new[] { $"[env:    ={value}]" });
+            await config.InvokeAsync(new[] { $"[env:    ={value}]" });
 
             asserted.Should().BeTrue();
         }
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
index f0fa6764ed..04d6e53bcd 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
@@ -92,17 +92,17 @@ public void Option_can_customize_first_column_text_based_on_parse_result()
                                           ctx.Command.Equals(commandA) 
                                               ? optionAFirstColumnText
                                               : optionBFirstColumnText);
-                var parser = new CommandLineBuilder(command)
+                var config = new CommandLineBuilder(command)
                              .UseDefaults()
                              .UseHelpBuilder(_ => helpBuilder)
                              .Build();
 
                 var console = new TestConsole();
-                parser.Invoke("root a -h", console);
+                config.Invoke("root a -h", console);
                 console.Out.ToString().Should().Contain(optionAFirstColumnText);
 
                 console = new TestConsole();
-                parser.Invoke("root b -h", console);
+                config.Invoke("root b -h", console);
                 console.Out.ToString().Should().Contain(optionBFirstColumnText);
             }
 
@@ -131,17 +131,17 @@ public void Option_can_customize_second_column_text_based_on_parse_result()
                                               ? optionADescription
                                               : optionBDescription);
 
-                var parser = new CommandLineBuilder(command)
+                var config = new CommandLineBuilder(command)
                              .UseDefaults()
                              .UseHelpBuilder(_ => helpBuilder)
                              .Build();
 
                 var console = new TestConsole();
-                parser.Invoke("root a -h", console);
+                config.Invoke("root a -h", console);
                 console.Out.ToString().Should().Contain($"option          {optionADescription}");
 
                 console = new TestConsole();
-                parser.Invoke("root b -h", console);
+                config.Invoke("root b -h", console);
                 console.Out.ToString().Should().Contain($"option          {optionBDescription}");
             }
 
@@ -247,13 +247,13 @@ public void Option_can_fallback_to_default_when_customizing(bool conditionA, boo
                     secondColumnText: ctx => conditionB ? "custom 2nd" : HelpBuilder.Default.GetIdentifierSymbolDescription(option));
 
 
-                var parser = new CommandLineBuilder(command)
+                var config = new CommandLineBuilder(command)
                              .UseDefaults()
                              .UseHelpBuilder(_ => helpBuilder)
                              .Build();
 
                 var console = new TestConsole();
-                parser.Invoke("test -h", console);
+                config.Invoke("test -h", console);
                 console.Out.ToString().Should().MatchRegex(expected);
             }
 
@@ -285,13 +285,13 @@ public void Argument_can_fallback_to_default_when_customizing(
                     defaultValue: ctx => conditionC ? "custom def" : HelpBuilder.Default.GetArgumentDefaultValue(argument));
 
 
-                var parser = new CommandLineBuilder(command)
+                var config = new CommandLineBuilder(command)
                              .UseDefaults()
                              .UseHelpBuilder(_ => helpBuilder)
                              .Build();
 
                 var console = new TestConsole();
-                parser.Invoke("test -h", console);
+                config.Invoke("test -h", console);
                 console.Out.ToString().Should().MatchRegex(expected);
             }
         }
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs b/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
index b8076fe9bc..4ee61aa4fe 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
@@ -1207,11 +1207,11 @@ public void Required_options_are_indicated_when_argument_is_named()
         [Fact]
         public void Help_option_is_shown_in_help()
         {
-            var parser = new CommandLineBuilder()
+            var configuration = new CommandLineBuilder(new RootCommand())
                          .UseHelp()
                          .Build();
 
-            _helpBuilder.Write(parser.Configuration.RootCommand, _console);
+            _helpBuilder.Write(configuration.RootCommand, _console);
 
             var help = _console.ToString();
 
diff --git a/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs b/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs
index 3bb8606059..98b014bd9a 100644
--- a/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs
+++ b/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs
@@ -22,12 +22,12 @@ public async Task General_invocation_middleware_can_be_specified_in_the_CommandL
         {
             var wasCalled = false;
 
-            var parser =
+            var config =
                 new CommandLineBuilder(new RootCommand { new Command("command") })
                     .AddMiddleware(_ => wasCalled = true)
                     .Build();
 
-            await parser.InvokeAsync("command", _console);
+            await config.InvokeAsync("command", _console);
 
             wasCalled.Should().BeTrue();
         }
@@ -44,14 +44,14 @@ public async Task InvokeAsync_chooses_the_appropriate_command()
             var second = new Command("second");
             second.SetHandler(() => secondWasCalled = true);
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              first,
                              second
                          })
                          .Build();
 
-            await parser.InvokeAsync("first", _console);
+            await config.InvokeAsync("first", _console);
 
             firstWasCalled.Should().BeTrue();
             secondWasCalled.Should().BeFalse();
@@ -69,14 +69,14 @@ public void Invoke_chooses_the_appropriate_command()
             var second = new Command("second");
             second.SetHandler(() => secondWasCalled = true);
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              first,
                              second
                          })
                 .Build();
 
-            parser.Invoke("first", _console);
+            config.Invoke("first", _console);
 
             firstWasCalled.Should().BeTrue();
             secondWasCalled.Should().BeFalse();
@@ -85,14 +85,14 @@ public void Invoke_chooses_the_appropriate_command()
         [Fact]
         public void When_middleware_throws_then_InvokeAsync_does_not_handle_the_exception()
         {
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              new Command("the-command")
                          })
                          .AddMiddleware(_ => throw new Exception("oops!"))
                          .Build();
 
-            Func<Task> invoke = async () => await parser.InvokeAsync("the-command", _console);
+            Func<Task> invoke = async () => await config.InvokeAsync("the-command", _console);
 
             invoke.Should()
                   .Throw<Exception>()
@@ -102,14 +102,14 @@ public void When_middleware_throws_then_InvokeAsync_does_not_handle_the_exceptio
         [Fact]
         public void When_middleware_throws_then_Invoke_does_not_handle_the_exception()
         {
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              new Command("the-command")
                          })
                          .AddMiddleware(_ => throw new Exception("oops!"))
                          .Build();
 
-            Func<int> invoke = () => parser.Invoke("the-command", _console);
+            Func<int> invoke = () => config.Invoke("the-command", _console);
 
             invoke.Should()
                 .Throw<Exception>()
@@ -129,13 +129,13 @@ public void When_command_handler_throws_then_InvokeAsync_does_not_handle_the_exc
 #pragma warning restore CS0162
                 });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
                          .Build();
 
-            Func<Task> invoke = async () => await parser.InvokeAsync("the-command", _console);
+            Func<Task> invoke = async () => await config.InvokeAsync("the-command", _console);
 
             invoke.Should()
                   .Throw<Exception>()
@@ -158,13 +158,13 @@ public void When_command_handler_throws_then_Invoke_does_not_handle_the_exceptio
 #pragma warning restore CS0162
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
                 .Build();
 
-            Func<int> invoke = () => parser.Invoke("the-command", _console);
+            Func<int> invoke = () => config.Invoke("the-command", _console);
 
             invoke.Should()
                 .Throw<Exception>()
@@ -188,7 +188,7 @@ public async Task ParseResult_can_be_replaced_by_middleware()
                 return Task.FromResult(0);
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var configuration = new CommandLineBuilder(new RootCommand
                          {
                             command
                          })
@@ -200,12 +200,12 @@ public async Task ParseResult_can_be_replaced_by_middleware()
                                                  .Concat(new[] { "implicit-inner-command" })
                                                  .ToArray();
 
-                             context.ParseResult = context.Parser.Parse(tokens);
+                             context.ParseResult = context.ParseResult.Configuration.RootCommand.Parse(tokens);
                              await next(context, token);
                          })
                          .Build();
 
-            await parser.InvokeAsync("the-command", new TestConsole());
+            await configuration.InvokeAsync("the-command", new TestConsole());
 
             wasCalled.Should().BeTrue();
         }
@@ -224,7 +224,7 @@ public async Task Invocation_can_be_short_circuited_by_middleware_by_not_calling
                 return Task.FromResult(0);
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
@@ -235,7 +235,7 @@ public async Task Invocation_can_be_short_circuited_by_middleware_by_not_calling
                          })
                          .Build();
 
-            await parser.InvokeAsync("the-command", new TestConsole());
+            await config.InvokeAsync("the-command", new TestConsole());
 
             middlewareWasCalled.Should().BeTrue();
             handlerWasCalled.Should().BeFalse();
@@ -255,7 +255,7 @@ public void Synchronous_invocation_can_be_short_circuited_by_async_middleware_by
                 return Task.FromResult(0);
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
@@ -266,7 +266,7 @@ public void Synchronous_invocation_can_be_short_circuited_by_async_middleware_by
                          })
                          .Build();
 
-            parser.Invoke("the-command", new TestConsole());
+            config.Invoke("the-command", new TestConsole());
 
             middlewareWasCalled.Should().BeTrue();
             handlerWasCalled.Should().BeFalse();
@@ -285,13 +285,13 @@ public async Task When_no_help_builder_is_specified_it_uses_default_implementati
                 return Task.FromResult(0);
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
                          .Build();
 
-            await parser.InvokeAsync("help-command", new TestConsole());
+            await config.InvokeAsync("help-command", new TestConsole());
 
             handlerWasCalled.Should().BeTrue();
         }
@@ -313,7 +313,7 @@ public async Task When_help_builder_factory_is_specified_it_is_used_to_create_th
                 return Task.FromResult(0);
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
@@ -324,7 +324,7 @@ public async Task When_help_builder_factory_is_specified_it_is_used_to_create_th
                          })
                          .Build();
 
-            await parser.InvokeAsync("help-command", new TestConsole());
+            await config.InvokeAsync("help-command", new TestConsole());
 
             handlerWasCalled.Should().BeTrue();
             factoryWasCalled.Should().BeTrue();
@@ -342,7 +342,7 @@ public async Task Middleware_can_throw_OperationCancelledException()
                 return Task.FromResult(0);
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
@@ -353,7 +353,7 @@ public async Task Middleware_can_throw_OperationCancelledException()
                          .UseExceptionHandler((ex, ctx) => ctx.ExitCode = ex is OperationCanceledException ? 123 : 456)
                          .Build();
 
-            int result = await parser.InvokeAsync("the-command");
+            int result = await config.InvokeAsync("the-command");
 
             // when the middleware throws, we never get to handler
             handlerWasCalled.Should().BeFalse();
diff --git a/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs b/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs
index 34b466b86e..93c55270d5 100644
--- a/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs
+++ b/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs
@@ -15,16 +15,14 @@ public class TypoCorrectionTests
         public async Task When_option_is_mistyped_it_is_suggested()
         {
             var option = new Option<string>("info");
+            RootCommand rootCommand = new () { option };
 
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        option
-                    })
+            var config =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
 
-            var result = parser.Parse("niof");
+            var result = rootCommand.Parse("niof", config);
 
             await result.InvokeAsync(_console);
 
@@ -35,16 +33,14 @@ public async Task When_option_is_mistyped_it_is_suggested()
         public async Task When_there_are_no_matches_then_nothing_is_suggested()
         {
             var option = new Option<bool>("info");
+            RootCommand rootCommand = new() { option };
 
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        option
-                    })
+            var configuration =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
 
-            var result = parser.Parse("zzzzzzz");
+            var result = rootCommand.Parse("zzzzzzz", configuration);
 
             await result.InvokeAsync(_console);
 
@@ -55,16 +51,14 @@ public async Task When_there_are_no_matches_then_nothing_is_suggested()
         public async Task When_command_is_mistyped_it_is_suggested()
         {
             var command = new Command("restore");
+            RootCommand rootCommand = new() { command };
 
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        command
-                    })
+            var configuration =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
 
-            var result = parser.Parse("sertor");
+            var result = rootCommand.Parse("sertor", configuration);
 
             await result.InvokeAsync(_console);
 
@@ -78,18 +72,19 @@ public async Task When_there_are_multiple_matches_it_picks_the_best_matches()
             var seenCommand = new Command("seen");
             var aOption = new Option<bool>("a");
             var beenOption = new Option<bool>("been");
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        fromCommand,
-                        seenCommand,
-                        aOption,
-                        beenOption
-                    })
+            RootCommand rootCommand = new ()
+            {
+                fromCommand,
+                seenCommand,
+                aOption,
+                beenOption
+            };
+            var configuration =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
 
-            var result = parser.Parse("een");
+            var result = rootCommand.Parse("een", configuration);
 
             await result.InvokeAsync(_console);
 
@@ -102,18 +97,19 @@ public async Task Hidden_commands_are_not_suggested()
             var fromCommand = new Command("from");
             var seenCommand = new Command("seen") { IsHidden = true };
             var beenCommand = new Command("been");
-
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        fromCommand,
-                        seenCommand,
-                        beenCommand
-                    })
+            RootCommand rootCommand = new RootCommand
+            {
+                fromCommand,
+                seenCommand,
+                beenCommand
+            };
+
+            var configuration =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
 
-            var result = parser.Parse("een");
+            var result = rootCommand.Parse("een", configuration);
 
             await result.InvokeAsync(_console);
 
@@ -125,17 +121,17 @@ public async Task Arguments_are_not_suggested()
         {
             var argument = new Argument<string>("the-argument");
             var command = new Command("been");
-
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        argument,
-                        command
-                    })
+            var rootCommand = new RootCommand
+            {
+                argument,
+                command
+            };
+            var configuration =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
 
-            var result = parser.Parse("een");
+            var result = rootCommand.Parse("een", configuration);
 
             await result.InvokeAsync(_console);
 
@@ -148,17 +144,18 @@ public async Task Hidden_options_are_not_suggested()
             var fromOption = new Option<string>("from");
             var seenOption = new Option<string>("seen") { IsHidden = true };
             var beenOption = new Option<string>("been");
-
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        fromOption,
-                        seenOption,
-                        beenOption
-                    })
+            var rootCommand = new RootCommand
+            {
+                fromOption,
+                seenOption,
+                beenOption
+            };
+            var config =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
-            var result = parser.Parse("een");
+
+            var result = rootCommand.Parse("een", config);
 
             await result.InvokeAsync(_console);
 
@@ -168,15 +165,16 @@ public async Task Hidden_options_are_not_suggested()
         [Fact]
         public async Task Suggestions_favor_matches_with_prefix()
         {
-            var parser =
-                new CommandLineBuilder(new RootCommand
-                    {
-                        new Option<string>(new[] { "/call", "-call", "--call" }),
-                        new Option<string>(new[] { "/email", "-email", "--email" })
-                    })
+            var rootCommand = new RootCommand
+            {
+                new Option<string>(new[] { "/call", "-call", "--call" }),
+                new Option<string>(new[] { "/email", "-email", "--email" })
+            };
+            var config =
+                new CommandLineBuilder(rootCommand)
                     .UseTypoCorrections()
                     .Build();
-            var result = parser.Parse("-all");
+            var result = rootCommand.Parse("-all", config);
 
             await result.InvokeAsync(_console);
 
diff --git a/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs b/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs
index ee24d691c0..84c388a735 100644
--- a/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs
+++ b/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs
@@ -127,7 +127,7 @@ public void All_consumed_tokens_are_present_in_option_result()
                         AllowMultipleArgumentsPerToken = true
                     };
 
-                    var result = option.Parse("-x 1 -x 2 -x 3 -x 4");
+                    var result = new RootCommand { option }.Parse("-x 1 -x 2 -x 3 -x 4");
 
                     _output.WriteLine(result.Diagram());
 
diff --git a/src/System.CommandLine.Tests/OptionTests.cs b/src/System.CommandLine.Tests/OptionTests.cs
index f87e74c5c0..0c71239bd8 100644
--- a/src/System.CommandLine.Tests/OptionTests.cs
+++ b/src/System.CommandLine.Tests/OptionTests.cs
@@ -203,7 +203,7 @@ public void When_options_use_different_prefixes_they_still_work(string prefix)
             var result = rootCommand.Parse(prefix + "c value-for-c " + prefix + "a value-for-a");
 
             result.GetValue(optionA).Should().Be("value-for-a");
-            result.HasOption(optionB).Should().BeFalse();
+            result.FindResultFor(optionB).Should().BeNull();
             result.GetValue(optionC).Should().Be("value-for-c");
         }
 
@@ -244,7 +244,7 @@ public void Option_T_default_value_can_be_set_via_the_constructor()
                 parseArgument: parsed => 123,
                 isDefault: true);
 
-            option
+            new RootCommand { option }
                 .Parse("")
                 .FindResultFor(option)
                 .GetValueOrDefault()
@@ -259,7 +259,7 @@ public void Option_T_default_value_can_be_set_after_instantiation()
 
             option.SetDefaultValue(123);
 
-            option
+            new RootCommand { option }
                 .Parse("")
                 .FindResultFor(option)
                 .GetValueOrDefault()
@@ -274,7 +274,7 @@ public void Option_T_default_value_factory_can_be_set_after_instantiation()
 
             option.SetDefaultValueFactory(() => 123);
 
-            option
+            new RootCommand { option }
                 .Parse("")
                 .FindResultFor(option)
                 .GetValueOrDefault()
@@ -293,7 +293,7 @@ public void Option_T_default_value_is_validated()
                                                                 .Select(_ => "ERR")
                                                                 .First()));
 
-            option
+            new RootCommand { option }
                 .Parse("-x 123")
                 .Errors
                 .Select(e => e.Message)
@@ -306,10 +306,10 @@ public void Option_of_string_defaults_to_null_when_not_specified()
         {
             var option = new Option<string>("-x");
 
-            var result = option.Parse("");
-            result.HasOption(option)
+            var result = new RootCommand { option }.Parse("");
+            result.FindResultFor(option)
                 .Should()
-                .BeFalse();
+                .BeNull();
             result.GetValue(option)
                 .Should()
                 .BeNull();
@@ -335,7 +335,7 @@ public void When_aliases_overlap_the_longer_alias_is_chosen(string parseInput)
         {
             var option = new Option<string>(new[] { "-o", "-option" });
 
-            var parseResult = option.Parse(parseInput);
+            var parseResult = new RootCommand { option }.Parse(parseInput);
 
             parseResult.GetValue(option).Should().Be("value");
         }
@@ -345,11 +345,11 @@ public void Option_of_boolean_defaults_to_false_when_not_specified()
         {
             var option = new Option<bool>("-x");
 
-            var result = option.Parse("");
+            var result = new RootCommand { option }.Parse("");
 
-            result.HasOption(option)
+            result.FindResultFor(option)
                 .Should()
-                .BeFalse();
+                .BeNull();
             result.GetValue(option)
                 .Should()
                 .BeFalse();
@@ -361,7 +361,7 @@ public void Option_of_enum_can_limit_enum_members_as_valid_values()
             Option<ConsoleColor> option = new("--color");
             option.AcceptOnlyFromAmong(ConsoleColor.Red.ToString(), ConsoleColor.Green.ToString());
 
-            var result = option.Parse("--color Fuschia");
+            var result = new RootCommand { option }.Parse("--color Fuschia");
 
             result.Errors
                 .Select(e => e.Message)
diff --git a/src/System.CommandLine.Tests/ParseDiagramTests.cs b/src/System.CommandLine.Tests/ParseDiagramTests.cs
index 2c78cab848..3b5ee6ad97 100644
--- a/src/System.CommandLine.Tests/ParseDiagramTests.cs
+++ b/src/System.CommandLine.Tests/ParseDiagramTests.cs
@@ -13,16 +13,16 @@ public class ParseDiagramTests
         [Fact]
         public void Parse_result_diagram_helps_explain_parse_operation()
         {
-            var parser = new Parser(
+            Command command = 
                 new Command(
                     "the-command")
                 {
                     new Option<string>("-x"),
                     new Option<bool>("-y"),
                     new Argument<string[]>()
-                });
+                };
 
-            var result = parser.Parse("the-command -x one -y two three");
+            var result = command.Parse("the-command -x one -y two three");
 
             result.Diagram()
                   .Should()
diff --git a/src/System.CommandLine.Tests/ParseDirectiveTests.cs b/src/System.CommandLine.Tests/ParseDirectiveTests.cs
index d66b879cb0..5e467784b0 100644
--- a/src/System.CommandLine.Tests/ParseDirectiveTests.cs
+++ b/src/System.CommandLine.Tests/ParseDirectiveTests.cs
@@ -28,11 +28,11 @@ public async Task Parse_directive_writes_parse_diagram()
             var option = new Option<int>(new[] { "-c", "--count" });
             subcommand.Options.Add(option);
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                          .UseParseDirective()
                          .Build();
 
-            var result = parser.Parse("[parse] subcommand -c 34 --nonexistent wat");
+            var result = rootCommand.Parse("[parse] subcommand -c 34 --nonexistent wat", config);
 
             output.WriteLine(result.Diagram());
 
@@ -51,13 +51,13 @@ public async Task When_parse_directive_is_used_the_help_is_not_displayed()
         {
             var rootCommand = new RootCommand();
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                          .UseParseDirective()
                          .UseVersionOption()
                          .UseHelp()
                          .Build();
 
-            var result = parser.Parse("[parse] --help");
+            var result = rootCommand.Parse("[parse] --help", config);
 
             output.WriteLine(result.Diagram());
 
@@ -76,13 +76,13 @@ public async Task When_parse_directive_is_used_the_version_is_not_displayed()
         {
             var rootCommand = new RootCommand();
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                          .UseParseDirective()
                          .UseVersionOption()
                          .UseHelp()
                          .Build();
 
-            var result = parser.Parse("[parse] --version");
+            var result = rootCommand.Parse("[parse] --version", config);
 
             output.WriteLine(result.Diagram());
 
diff --git a/src/System.CommandLine.Tests/ParseResultTests.cs b/src/System.CommandLine.Tests/ParseResultTests.cs
index d7ed496943..bd74cf03ad 100644
--- a/src/System.CommandLine.Tests/ParseResultTests.cs
+++ b/src/System.CommandLine.Tests/ParseResultTests.cs
@@ -25,7 +25,7 @@ public void An_option_with_a_default_value_and_no_explicitly_provided_argument_h
         }
 
         [Fact]
-        public void HasOption_can_be_used_to_check_the_presence_of_an_option()
+        public void FindResult_can_be_used_to_check_the_presence_of_an_option()
         {
             var option = new Option<bool>(new[] { "-h", "--help" });
 
@@ -36,11 +36,11 @@ public void HasOption_can_be_used_to_check_the_presence_of_an_option()
 
             var result = command.Parse("the-command -h");
 
-            result.HasOption(option).Should().BeTrue();
+            result.FindResultFor(option).Should().NotBeNull();
         }
 
         [Fact]
-        public void HasOption_can_be_used_to_check_the_presence_of_an_implicit_option()
+        public void FindResultFor_can_be_used_to_check_the_presence_of_an_implicit_option()
         {
             var option = new Option<int>(new[] { "-c", "--count" }, () => 5);
             var command = new Command("the-command")
@@ -50,7 +50,7 @@ public void HasOption_can_be_used_to_check_the_presence_of_an_implicit_option()
 
             var result = command.Parse("the-command");
 
-            result.HasOption(option).Should().BeTrue();
+            result.FindResultFor(option).Should().NotBeNull();
         }
 
         [Fact]
@@ -74,12 +74,12 @@ public void Command_will_not_accept_a_command_if_a_sibling_command_has_already_b
                 }
             };
 
-            var result = new Parser(command).Parse("outer inner-one inner-two");
+            var result = Parser.Parse(command, "outer inner-one inner-two");
 
             result.CommandResult.Command.Name.Should().Be("inner-one");
             result.Errors.Count.Should().Be(1);
 
-            var result2 = new Parser(command).Parse("outer inner-two inner-one");
+            var result2 = Parser.Parse(command, "outer inner-two inner-one");
 
             result2.CommandResult.Command.Name.Should().Be("inner-two");
             result2.Errors.Count.Should().Be(1);
@@ -112,7 +112,7 @@ public void ParseResult_GetCompletions_returns_global_options_of_given_command_o
                 midCommand2
             };
 
-            var result = new Parser(rootCommand).Parse("root midCommand2 leafCommand --");
+            var result = Parser.Parse(rootCommand, "root midCommand2 leafCommand --");
 
             var completions = result.GetCompletions();
 
diff --git a/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs b/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs
index 4ac3c6b415..4c70908eff 100644
--- a/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs
+++ b/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs
@@ -23,11 +23,12 @@ public void Subsequent_tokens_are_parsed_as_arguments_even_if_they_match_option_
                     argument
                 };
 
-                var result = new CommandLineBuilder(rootCommand)
-                             .Build()
-                             .Parse("-o \"some stuff\" -- -o --one -x -y -z -o:foo");
+                var configuration = new CommandLineBuilder(rootCommand)
+                             .Build();
 
-                result.HasOption(option).Should().BeTrue();
+                var result = rootCommand.Parse("-o \"some stuff\" -- -o --one -x -y -z -o:foo", configuration);
+
+                result.FindResultFor(option).Should().NotBeNull();
 
                 result.GetValue(option).Should().BeEquivalentTo("some stuff");
 
@@ -47,9 +48,8 @@ public void Unmatched_tokens_is_empty()
                     argument
                 };
 
-                var result = new CommandLineBuilder(rootCommand)
-                             .Build()
-                             .Parse("-o \"some stuff\" -- --one -x -y -z -o:foo");
+                var config = new CommandLineBuilder(rootCommand).Build();
+                var result = rootCommand.Parse("-o \"some stuff\" -- --one -x -y -z -o:foo", config);
 
                 result.UnmatchedTokens.Should().BeEmpty();
             }
@@ -64,10 +64,9 @@ public void No_errors_are_generated()
                     option,
                     argument
                 };
+                var config = new CommandLineBuilder(rootCommand).Build();
 
-                var result = new CommandLineBuilder(rootCommand)
-                             .Build()
-                             .Parse("-o \"some stuff\" -- -o --one -x -y -z -o:foo");
+                var result = rootCommand.Parse("-o \"some stuff\" -- -o --one -x -y -z -o:foo", config);
 
                 result.Errors.Should().BeEmpty();
             }
@@ -81,9 +80,9 @@ public void A_second_double_dash_is_parsed_as_an_argument()
                     argument
                 };
 
-                var result = new CommandLineBuilder(rootCommand)
-                             .Build()
-                             .Parse("a b c -- -- d");
+                var configuration = new CommandLineBuilder(rootCommand).Build();
+
+                var result = rootCommand.Parse("a b c -- -- d", configuration);
 
                 var strings = result.GetValue(argument);
 
diff --git a/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs b/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs
index 27a1abdce7..347d93e113 100644
--- a/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs
+++ b/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs
@@ -302,7 +302,7 @@ public void When_there_are_not_enough_tokens_for_all_arguments_then_the_correct_
                     new Argument<string>()
                 };
 
-                var result = new Parser(command).Parse(providedArgs);
+                var result = Parser.Parse(command, providedArgs);
 
                 var numberOfMissingArgs =
                     result
diff --git a/src/System.CommandLine.Tests/ParserTests.cs b/src/System.CommandLine.Tests/ParserTests.cs
index fc8afed147..16644eeef1 100644
--- a/src/System.CommandLine.Tests/ParserTests.cs
+++ b/src/System.CommandLine.Tests/ParserTests.cs
@@ -28,11 +28,11 @@ public void An_option_can_be_checked_by_object_instance()
         {
             var option = new Option<bool>("--flag");
             var option2 = new Option<bool>("--flag2");
-            var result = new Parser(new RootCommand { option, option2 })
+            var result = new RootCommand { option, option2 }
                 .Parse("--flag");
 
-            result.HasOption(option).Should().BeTrue();
-            result.HasOption(option2).Should().BeFalse();
+            result.FindResultFor(option).Should().NotBeNull();
+            result.FindResultFor(option2).Should().BeNull();
         }
 
         [Fact]
@@ -42,16 +42,10 @@ public void Two_options_are_parsed_correctly()
 
             var optionTwo = new Option<bool>(new[] { "-t", "--two" });
 
-            var result = new Parser(
-                    new RootCommand
-                    {
-                        optionOne,
-                        optionTwo
-                    })
-                .Parse("-o -t");
+            var result = new RootCommand { optionOne, optionTwo }.Parse("-o -t");
 
-            result.HasOption(optionOne).Should().BeTrue();
-            result.HasOption(optionTwo).Should().BeTrue();
+            result.FindResultFor(optionOne).Should().NotBeNull();
+            result.FindResultFor(optionTwo).Should().NotBeNull();
         }
 
         [Theory]
@@ -59,9 +53,7 @@ public void Two_options_are_parsed_correctly()
         [InlineData("/")]
         public void When_a_token_is_just_a_prefix_then_an_error_is_returned(string prefix)
         {
-            var parser = new Parser(new RootCommand());
-
-            var result = parser.Parse(prefix);
+            var result = new RootCommand().Parse(prefix);
 
             result.Errors
                   .Select(e => e.Message)
@@ -74,7 +66,7 @@ public void Short_form_options_can_be_specified_using_equals_delimiter()
         {
             var option = new Option<string>("-x");
 
-            var result = option.Parse("-x=some-value");
+            var result = new RootCommand { option }.Parse("-x=some-value");
 
             result.Errors.Should().BeEmpty();
 
@@ -86,7 +78,7 @@ public void Long_form_options_can_be_specified_using_equals_delimiter()
         {
             var option = new Option<string>("--hello");
 
-            var result = option.Parse("--hello=there");
+            var result = new RootCommand { option }.Parse("--hello=there");
 
             result.Errors.Should().BeEmpty();
 
@@ -98,7 +90,7 @@ public void Short_form_options_can_be_specified_using_colon_delimiter()
         {
             var option = new Option<string>("-x");
 
-            var result = option.Parse("-x:some-value");
+            var result = new RootCommand { option }.Parse("-x:some-value");
 
             result.Errors.Should().BeEmpty();
 
@@ -110,7 +102,7 @@ public void Long_form_options_can_be_specified_using_colon_delimiter()
         {
             var option = new Option<string>("--hello");
 
-            var result = option.Parse("--hello:there");
+            var result = new RootCommand { option }.Parse("--hello:there");
 
             result.Errors.Should().BeEmpty();
 
@@ -137,19 +129,21 @@ public void Option_short_forms_can_be_bundled()
         [Fact]
         public void Options_short_forms_do_not_get_unbundled_if_unbundling_is_turned_off()
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             new Command("the-command")
-                             {
-                                 new Option<bool>("-x"),
-                                 new Option<bool>("-y"),
-                                 new Option<bool>("-z")
-                             }
-                         })
+            RootCommand rootCommand = new RootCommand()
+            {
+                new Command("the-command")
+                {
+                    new Option<bool>("-x"),
+                    new Option<bool>("-y"),
+                    new Option<bool>("-z")
+                }
+            };
+
+            var configuration = new CommandLineBuilder(rootCommand)
                          .EnablePosixBundling(false)
                          .Build();
 
-            var result = parser.Parse("the-command -xyz");
+            var result = rootCommand.Parse("the-command -xyz", configuration);
 
             result.UnmatchedTokens
                   .Should()
@@ -159,16 +153,16 @@ public void Options_short_forms_do_not_get_unbundled_if_unbundling_is_turned_off
         [Fact]
         public void Option_long_forms_do_not_get_unbundled()
         {
-            var parser = new Parser(
+            Command command =
                 new Command("the-command")
                 {
                     new Option<bool>("--xyz"),
                     new Option<bool>("-x"),
                     new Option<bool>("-y"),
                     new Option<bool>("-z")
-                });
+                };
 
-            var result = parser.Parse("the-command --xyz");
+            var result = command.Parse("the-command --xyz");
 
             result.CommandResult
                   .Children
@@ -190,9 +184,7 @@ public void Options_do_not_get_unbundled_unless_all_resulting_options_would_be_v
             inner.Options.Add(new Option<bool>("-c"));
             outer.Subcommands.Add(inner);
 
-            var parser = new Parser(outer);
-
-            ParseResult result = parser.Parse("outer inner -abc");
+            ParseResult result = outer.Parse("outer inner -abc");
 
             result.CommandResult
                   .Tokens
@@ -238,8 +230,8 @@ public void Last_bundled_option_can_accept_argument_with_no_separator()
             };
 
             var result = command.Parse("-abcvalue");
-            result.HasOption(optionA).Should().BeTrue();
-            result.HasOption(optionB).Should().BeTrue();
+            result.FindResultFor(optionA).Should().NotBeNull();
+            result.FindResultFor(optionB).Should().NotBeNull();
 
             result.FindResultFor(optionC)
                 .Tokens
@@ -262,8 +254,8 @@ public void Last_bundled_option_can_accept_argument_with_equals_separator()
             };
 
             var result = command.Parse("-abc=value");
-            result.HasOption(optionA).Should().BeTrue();
-            result.HasOption(optionB).Should().BeTrue();
+            result.FindResultFor(optionA).Should().NotBeNull();
+            result.FindResultFor(optionB).Should().NotBeNull();
 
             result.FindResultFor(optionC)
                 .Tokens
@@ -286,8 +278,8 @@ public void Last_bundled_option_can_accept_argument_with_colon_separator()
             };
 
             var result = command.Parse("-abc:value");
-            result.HasOption(optionA).Should().BeTrue();
-            result.HasOption(optionB).Should().BeTrue();
+            result.FindResultFor(optionA).Should().NotBeNull();
+            result.FindResultFor(optionB).Should().NotBeNull();
 
             result.FindResultFor(optionC)
                 .Tokens
@@ -310,15 +302,15 @@ public void Invalid_char_in_bundle_causes_rest_to_be_interpreted_as_value()
             };
 
             var result = command.Parse("-abvcalue");
-            result.HasOption(optionA).Should().BeTrue();
-            result.HasOption(optionB).Should().BeTrue();
+            result.FindResultFor(optionA).Should().NotBeNull();
+            result.FindResultFor(optionB).Should().NotBeNull();
 
             result.FindResultFor(optionB)
                 .Tokens
                 .Should()
                 .ContainSingle(t => t.Value == "vcalue");
 
-            result.HasOption(optionC).Should().BeFalse();
+            result.FindResultFor(optionC).Should().BeNull();
         }
 
         [Fact]
@@ -353,13 +345,13 @@ public void Options_can_be_specified_multiple_times_and_their_arguments_are_coll
             var animalsOption = new Option<string[]>(new[] { "-a", "--animals" });
             animalsOption.AcceptOnlyFromAmong("dog", "cat", "sheep");
             var vegetablesOption = new Option<string[]>(new[] { "-v", "--vegetables" });
-            var parser = new Parser(
+            Command command =
                 new Command("the-command") {
                     animalsOption,
                     vegetablesOption
-                });
+                };
 
-            var result = parser.Parse("the-command -a cat -v carrot -a dog");
+            var result = command.Parse("the-command -a cat -v carrot -a dog");
 
             result.FindResultFor(animalsOption)
                   .Tokens
@@ -380,16 +372,16 @@ public void When_an_option_is_not_respecified_but_limit_is_reached_then_the_foll
             var animalsOption = new Option<string[]>(new[] { "-a", "--animals" });
 
             var vegetablesOption = new Option<string[]>(new[] { "-v", "--vegetables" });
-            
-            var parser = new Parser(
+
+            Command command = 
                 new Command("the-command")
                 {
                     animalsOption,
                     vegetablesOption,
                     new Argument<string[]>()
-                });
+                };
 
-            var result = parser.Parse("the-command -a cat some-arg -v carrot");
+            var result = command.Parse("the-command -a cat some-arg -v carrot");
 
             result.FindResultFor(animalsOption)
                   .Tokens
@@ -413,15 +405,13 @@ public void When_an_option_is_not_respecified_but_limit_is_reached_then_the_foll
         [Fact]
         public void Command_with_multiple_options_is_parsed_correctly()
         {
-            var option = new Command("outer")
+            var command = new Command("outer")
             {
                 new Option<string>("--inner1"),
                 new Option<string>("--inner2")
             };
 
-            var parser = new Parser(option);
-
-            var result = parser.Parse("outer --inner1 argument1 --inner2 argument2");
+            var result = command.Parse("outer --inner1 argument1 --inner2 argument2");
 
             result.CommandResult
                   .Children
@@ -768,11 +758,11 @@ public void Subsequent_occurrences_of_tokens_matching_command_names_are_parsed_a
                 }
             };
 
-            ParseResult result = command.Parse("the-command",
+            ParseResult result = command.Parse(new[] { "the-command",
                                                "complete",
                                                "--position",
                                                "7",
-                                               "the-command");
+                                               "the-command" });
 
             CommandResult completeResult = result.CommandResult;
 
@@ -782,15 +772,15 @@ public void Subsequent_occurrences_of_tokens_matching_command_names_are_parsed_a
         [Fact]
         public void Absolute_unix_style_paths_are_lexed_correctly()
         {
-            var command =
+            const string commandText =
                 @"rm ""/temp/the file.txt""";
 
-            var parser = new Parser(new Command("rm")
+            Command command = new ("rm")
             {
                 new Argument<string[]>()
-            });
+            };
 
-            var result = parser.Parse(command);
+            var result = command.Parse(commandText);
 
             result.CommandResult
                   .Tokens
@@ -802,15 +792,15 @@ public void Absolute_unix_style_paths_are_lexed_correctly()
         [Fact]
         public void Absolute_Windows_style_paths_are_lexed_correctly()
         {
-            var command =
+            const string commandText =
                 @"rm ""c:\temp\the file.txt\""";
 
-            var parser = new Parser(new Command("rm")
+            Command command = new("rm")
             {
                 new Argument<string[]>()
-            });
+            };
 
-            ParseResult result = parser.Parse(command);
+            ParseResult result = command.Parse(commandText);
 
             result.CommandResult
                   .Tokens
@@ -844,7 +834,7 @@ public void When_an_option_with_a_default_value_is_not_matched_then_the_option_c
 
             ParseResult result = command.Parse("command");
 
-            result.HasOption(option).Should().BeTrue();
+            result.FindResultFor(option).Should().NotBeNull();
             result.GetValue(option).Should().Be("the-default");
         }
 
@@ -984,27 +974,25 @@ public void Option_and_Command_can_have_the_same_alias()
                 new Argument<string[]>()
             };
 
-            var parser = new Parser(outerCommand);
-
-            parser.Parse("outer inner")
+            outerCommand.Parse("outer inner")
                   .CommandResult
                   .Command
                   .Should()
                   .BeSameAs(innerCommand);
 
-            parser.Parse("outer --inner")
+            outerCommand.Parse("outer --inner")
                   .CommandResult
                   .Command
                   .Should()
                   .BeSameAs(outerCommand);
 
-            parser.Parse("outer --inner inner")
+            outerCommand.Parse("outer --inner inner")
                   .CommandResult
                   .Command
                   .Should()
                   .BeSameAs(innerCommand);
 
-            parser.Parse("outer --inner inner")
+            outerCommand.Parse("outer --inner inner")
                   .CommandResult
                   .Parent
                   .Should()
@@ -1052,7 +1040,7 @@ public void When_an_option_argument_is_enclosed_in_double_quotes_its_value_retai
         {
             var option = new Option<string[]>("-x");
 
-            var parseResult = option.Parse(new[] { arg1, arg2 });
+            var parseResult = new RootCommand { option }.Parse(new[] { arg1, arg2 });
 
             parseResult
                 .FindResultFor(option)
@@ -1293,7 +1281,7 @@ public void Option_aliases_do_not_need_to_be_prefixed()
 
             var result = new RootCommand { option }.Parse("noprefix");
 
-            result.HasOption(option).Should().BeTrue();
+            result.FindResultFor(option).Should().NotBeNull();
         }
 
         [Fact]
@@ -1331,13 +1319,11 @@ public void When_a_command_line_has_unmatched_tokens_they_are_not_applied_to_sub
         }
 
         [Fact]
-        public void Parse_can_be_called_with_null_args()
+        public void Parse_can_not_be_called_with_null_args()
         {
-            var parser = new Parser(new RootCommand());
-
-            var result = parser.Parse(null);
+            Action passNull = () => new RootCommand().Parse(args: null);
 
-            result.CommandResult.Command.Name.Should().Be(RootCommand.ExecutableName);
+            passNull.Should().Throw<ArgumentNullException>();
         }
 
         [Fact]
diff --git a/src/System.CommandLine.Tests/ParsingValidationTests.cs b/src/System.CommandLine.Tests/ParsingValidationTests.cs
index 6a96cc730d..8ab17f547c 100644
--- a/src/System.CommandLine.Tests/ParsingValidationTests.cs
+++ b/src/System.CommandLine.Tests/ParsingValidationTests.cs
@@ -27,7 +27,7 @@ public void When_an_option_accepts_only_specific_arguments_but_a_wrong_one_is_su
             var option = new Option<string>("-x");
             option.AcceptOnlyFromAmong("this", "that", "the-other-thing");
 
-            var result = option.Parse("-x none-of-those");
+            var result = new RootCommand { option }.Parse("-x none-of-those");
 
             result.Errors
                   .Select(e => e.Message)
@@ -43,7 +43,7 @@ public void When_an_option_has_en_error_then_the_error_has_a_reference_to_the_op
             var option = new Option<string>("-x");
             option.AcceptOnlyFromAmong("this", "that");
 
-            var result = option.Parse("-x something_else");
+            var result = new RootCommand { option }.Parse("-x something_else");
 
             result.Errors
                   .Where(e => e.SymbolResult != null)
@@ -210,7 +210,7 @@ public void When_a_required_argument_is_not_supplied_then_an_error_is_returned()
         {
             var option = new Option<string>("-x");
 
-            var result = option.Parse("-x");
+            var result = new RootCommand { option }.Parse("-x");
 
             result.Errors
                   .Should()
@@ -311,16 +311,16 @@ public void Required_options_on_parent_commands_do_not_create_parse_errors_when_
         [Fact]
         public void When_no_option_accepts_arguments_but_one_is_supplied_then_an_error_is_returned()
         {
-            var parser = new Parser(
+            var command =
                 new Command("the-command")
                 {
                     new Option<bool>("-x")
                     {
                         Arity = ArgumentArity.Zero
                     }
-                });
+                };
 
-            var result = parser.Parse("the-command -x some-arg");
+            var result = command.Parse("the-command -x some-arg");
 
             _output.WriteLine(result.ToString());
 
@@ -561,7 +561,7 @@ public void The_parsed_value_of_an_argument_is_available_within_a_validator()
                 }
             });
 
-            var result = argument.Parse("-1");
+            var result = new RootCommand() { argument }.Parse("-1");
 
             result.Errors
                   .Should()
@@ -585,7 +585,7 @@ public void The_parsed_value_of_an_option_is_available_within_a_validator()
                 }
             });
 
-            var result = option.Parse("-x -1");
+            var result = new RootCommand { option }.Parse("-x -1");
 
             result.Errors
                   .Should()
@@ -1162,7 +1162,7 @@ public void When_an_option_has_a_default_value_it_is_not_valid_to_specify_the_op
         {
             var option = new Option<int>("-x", () => 123);
 
-            var result = option.Parse("-x");
+            var result = new RootCommand { option }.Parse("-x");
 
             result.Errors
                   .Select(e => e.Message)
diff --git a/src/System.CommandLine.Tests/ResponseFileTests.cs b/src/System.CommandLine.Tests/ResponseFileTests.cs
index d50eda4c20..47f079df57 100644
--- a/src/System.CommandLine.Tests/ResponseFileTests.cs
+++ b/src/System.CommandLine.Tests/ResponseFileTests.cs
@@ -45,9 +45,9 @@ public void When_response_file_specified_it_loads_options_from_response_file()
         {
             var option = new Option<bool>("--flag");
 
-            var result = option.Parse($"@{CreateResponseFile("--flag")}");
+            var result = new RootCommand { option }.Parse($"@{CreateResponseFile("--flag")}");
 
-            result.HasOption(option).Should().BeTrue();
+            result.FindResultFor(option).Should().NotBeNull();
         }
 
         [Fact]
@@ -68,7 +68,7 @@ public void When_response_file_is_specified_it_loads_options_with_arguments_from
                          }
                 .Parse($"@{responseFile}");
 
-            result.HasOption(optionOne).Should().BeTrue();
+            result.FindResultFor(optionOne).Should().NotBeNull();
             result.GetValue(optionTwo).Should().Be(123);
             result.Errors.Should().BeEmpty();
         }
@@ -203,8 +203,8 @@ public void Response_file_can_contain_comments_which_are_ignored_when_loaded()
                 optionTwo
             }.Parse($"@{responseFile}");
 
-            result.HasOption(optionOne).Should().BeTrue();
-            result.HasOption(optionTwo).Should().BeTrue();
+            result.FindResultFor(optionOne).Should().NotBeNull();
+            result.FindResultFor(optionTwo).Should().NotBeNull();
             result.Errors.Should().BeEmpty();
         }
 
@@ -220,8 +220,8 @@ public void When_response_file_does_not_exist_then_error_is_returned()
                              optionTwo
                          }.Parse("@nonexistent.rsp");
 
-            result.HasOption(optionOne).Should().BeFalse();
-            result.HasOption(optionTwo).Should().BeFalse();
+            result.FindResultFor(optionOne).Should().BeNull();
+            result.FindResultFor(optionTwo).Should().BeNull();
             result.Errors.Should().HaveCount(1);
             result.Errors.Single().Message.Should().Be("Response file not found 'nonexistent.rsp'.");
         }
@@ -239,8 +239,8 @@ public void When_response_filepath_is_not_specified_then_error_is_returned()
                          }
                 .Parse("@");
 
-            result.HasOption(optionOne).Should().BeFalse();
-            result.HasOption(optionTwo).Should().BeFalse();
+            result.FindResultFor(optionOne).Should().BeNull();
+            result.FindResultFor(optionTwo).Should().BeNull();
             result.Errors.Should().HaveCount(1);
             result.Errors
                   .Single()
@@ -264,8 +264,8 @@ public void When_response_file_cannot_be_read_then_specified_error_is_returned()
                                  optionTwo
                              }.Parse($"@{nonexistent}");
 
-                result.HasOption(optionOne).Should().BeFalse();
-                result.HasOption(optionTwo).Should().BeFalse();
+                result.FindResultFor(optionOne).Should().BeNull();
+                result.FindResultFor(optionTwo).Should().BeNull();
                 result.Errors.Should().HaveCount(1);
                 result.Errors.Single().Message.Should().StartWith($"Error reading response file '{nonexistent}'");
             }
@@ -287,10 +287,10 @@ public void When_response_file_parse_as_space_separated_returns_expected_values(
                 optionOne,
                 optionTwo
             };
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                          .Build();
 
-            var result = parser.Parse($"@{responseFile}");
+            var result = rootCommand.Parse($"@{responseFile}", config);
 
             result.GetValue(optionOne).Should().Be("first value");
             result.GetValue(optionTwo).Should().Be(123);
@@ -307,9 +307,7 @@ public void When_response_file_processing_is_disabled_then_it_returns_response_f
                 command,
                 enableTokenReplacement: false);
             
-            var parser = new Parser(configuration);
-
-            var result = parser.Parse("@file.rsp");
+            var result = Parser.Parse(command, "@file.rsp", configuration);
 
             result.Tokens
                   .Should()
diff --git a/src/System.CommandLine.Tests/SuggestDirectiveTests.cs b/src/System.CommandLine.Tests/SuggestDirectiveTests.cs
index ac1e03efd1..ad8d7d830f 100644
--- a/src/System.CommandLine.Tests/SuggestDirectiveTests.cs
+++ b/src/System.CommandLine.Tests/SuggestDirectiveTests.cs
@@ -36,14 +36,12 @@ public SuggestDirectiveTests()
         [Fact]
         public async Task It_writes_suggestions_for_option_arguments_when_under_subcommand()
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             _eatCommand
-                         })
+            RootCommand rootCommand = new () { _eatCommand };
+            var config = new CommandLineBuilder(rootCommand)
                          .UseSuggestDirective()
                          .Build();
 
-            var result = parser.Parse($"[suggest:13] \"eat --fruit\"");
+            var result = rootCommand.Parse($"[suggest:13] \"eat --fruit\"", config);
 
             var console = new TestConsole();
 
@@ -58,15 +56,16 @@ public async Task It_writes_suggestions_for_option_arguments_when_under_subcomma
         [Fact]
         public async Task It_writes_suggestions_for_option_arguments_when_under_root_command()
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             _fruitOption,
-                             _vegetableOption
-                         })
+            RootCommand rootCommand = new ()
+            {
+                _fruitOption,
+                _vegetableOption
+            };
+            var config = new CommandLineBuilder(rootCommand)
                          .UseSuggestDirective()
                          .Build();
 
-            var result = parser.Parse($"[suggest:8] \"--fruit\"");
+            var result = rootCommand.Parse($"[suggest:8] \"--fruit\"", config);
 
             var console = new TestConsole();
 
@@ -83,14 +82,12 @@ public async Task It_writes_suggestions_for_option_arguments_when_under_root_com
         [InlineData("[suggest:6] \"eat --\"")]
         public async Task It_writes_suggestions_for_option_aliases_under_subcommand(string commandLine)
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             _eatCommand
-                         })
+            RootCommand rootCommand = new() { _eatCommand };
+            var config = new CommandLineBuilder(rootCommand)
                          .UseSuggestDirective()
                          .Build();
 
-            var result = parser.Parse(commandLine);
+            var result = rootCommand.Parse(commandLine, config);
 
             var console = new TestConsole();
 
@@ -109,15 +106,16 @@ public async Task It_writes_suggestions_for_option_aliases_under_subcommand(stri
         [InlineData("[suggest:0] ")]
         public async Task It_writes_suggestions_for_option_aliases_under_root_command(string input)
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             _vegetableOption,
-                             _fruitOption
-                         })
+            RootCommand rootCommand = new()
+            {
+                _vegetableOption,
+                _fruitOption
+            };
+            var config = new CommandLineBuilder(rootCommand)
                          .UseSuggestDirective()
                          .Build();
 
-            var result = parser.Parse(input);
+            var result = rootCommand.Parse(input, config);
 
             var console = new TestConsole();
 
@@ -132,14 +130,12 @@ public async Task It_writes_suggestions_for_option_aliases_under_root_command(st
         [Fact]
         public async Task It_writes_suggestions_for_subcommand_aliases_under_root_command()
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             _eatCommand
-                         })
+            RootCommand rootCommand = new() { _eatCommand };
+            var config = new CommandLineBuilder(rootCommand)
                          .UseSuggestDirective()
                          .Build();
 
-            var result = parser.Parse("[suggest]");
+            var result = rootCommand.Parse("[suggest]", config);
 
             var console = new TestConsole();
 
@@ -154,15 +150,16 @@ public async Task It_writes_suggestions_for_subcommand_aliases_under_root_comman
         [Fact]
         public async Task It_writes_suggestions_for_partial_option_aliases_under_root_command()
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             _fruitOption,
-                             _vegetableOption
-                         })
+            RootCommand rootCommand = new()
+            {
+                _fruitOption,
+                _vegetableOption
+            };
+            var config = new CommandLineBuilder(rootCommand)
                          .UseSuggestDirective()
                          .Build();
 
-            var result = parser.Parse($"[suggest:1] \"f\"");
+            var result = rootCommand.Parse($"[suggest:1] \"f\"", config);
 
             var console = new TestConsole();
 
@@ -177,15 +174,16 @@ public async Task It_writes_suggestions_for_partial_option_aliases_under_root_co
         [Fact]
         public async Task It_writes_suggestions_for_partial_subcommand_aliases_under_root_command()
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                         {
-                             _eatCommand,
-                             new Command("wash-dishes")
-                         })
+            RootCommand rootCommand = new ()
+            {
+                _eatCommand,
+                new Command("wash-dishes")
+            }; 
+            var config = new CommandLineBuilder(rootCommand)
                          .UseSuggestDirective()
                          .Build();
 
-            var result = parser.Parse("[suggest:1] \"d\"");
+            var result = rootCommand.Parse("[suggest:1] \"d\"", config);
 
             var console = new TestConsole();
 
@@ -200,16 +198,17 @@ public async Task It_writes_suggestions_for_partial_subcommand_aliases_under_roo
         [Fact]
         public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliases_under_root_command()
         {
-            var parser = new CommandLineBuilder(new RootCommand
-                          {
-                              _eatCommand,
-                              new Command("wash-dishes")
-                          })
+            RootCommand rootCommand = new ()
+            {
+                _eatCommand,
+                new Command("wash-dishes")
+            };
+            var config = new CommandLineBuilder(rootCommand)
                           .UseSuggestDirective()
                           .UseVersionOption()
                           .Build();
 
-            var result = parser.Parse("[suggest:5] \"--ver\"");
+            var result = rootCommand.Parse("[suggest:5] \"--ver\"", config);
 
             var console = new TestConsole();
 
@@ -224,7 +223,7 @@ public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliase
         [Fact]
         public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliases_under_root_command_with_an_argument()
         {
-            var parser = new CommandLineBuilder(new Command("parent")
+            var config = new CommandLineBuilder(new Command("parent")
                           {
                               new Command("child"),
                               new Option<bool>("--option1"),
@@ -236,7 +235,7 @@ public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliase
 
             var console = new TestConsole();
 
-            await parser.InvokeAsync("[suggest:3] \"opt\"", console);
+            await config.InvokeAsync("[suggest:3] \"opt\"", console);
 
             console.Out
                    .ToString()
diff --git a/src/System.CommandLine.Tests/SymbolTests.cs b/src/System.CommandLine.Tests/SymbolTests.cs
index 71401618f9..728dab5982 100644
--- a/src/System.CommandLine.Tests/SymbolTests.cs
+++ b/src/System.CommandLine.Tests/SymbolTests.cs
@@ -18,25 +18,6 @@ public void When_Name_is_explicitly_set_then_adding_aliases_does_not_change_it()
             symbol.Name.Should().Be("changed");
         }
 
-        [Fact]
-        public void Parse_extension_method_reuses_implicit_parser_instance()
-        {
-            var symbol = CreateSymbol("x");
-
-            Func<ParseResult> parse = () => symbol switch
-            {
-                Argument argument => argument.Parse(""),
-                Command command => command.Parse(""),
-                Option option => option.Parse(""),
-                _ => throw new ArgumentOutOfRangeException(nameof(symbol))
-            };
-
-            var parser1 = parse().Parser;
-            var parser2 = parse().Parser;
-
-            parser1.Should().BeSameAs(parser2);
-        }
-
         protected abstract Symbol CreateSymbol(string name);
     }
 }
\ No newline at end of file
diff --git a/src/System.CommandLine.Tests/TokenReplacementTests.cs b/src/System.CommandLine.Tests/TokenReplacementTests.cs
index d615b70761..07dda8d03f 100644
--- a/src/System.CommandLine.Tests/TokenReplacementTests.cs
+++ b/src/System.CommandLine.Tests/TokenReplacementTests.cs
@@ -19,7 +19,7 @@ public void Token_replacer_receives_the_token_from_the_command_line_with_the_lea
 
         string receivedToken = null;
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          receivedToken = tokenToReplace;
@@ -29,7 +29,7 @@ public void Token_replacer_receives_the_token_from_the_command_line_with_the_lea
                      })
                      .Build();
 
-        parser.Parse("@replace-me");
+        command.Parse("@replace-me", config);
 
         receivedToken.Should().Be("replace-me");
     }
@@ -41,7 +41,7 @@ public void Token_replacer_can_expand_argument_values()
 
         var command = new RootCommand { argument };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = new[] { "123" };
@@ -50,7 +50,7 @@ public void Token_replacer_can_expand_argument_values()
                      })
                      .Build();
 
-        var result = parser.Parse("@replace-me");
+        var result = command.Parse("@replace-me", config);
 
         result.Errors.Should().BeEmpty();
 
@@ -64,7 +64,7 @@ public void Custom_token_replacer_can_expand_option_argument_values()
 
         var command = new RootCommand { option };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = new[] { "123" };
@@ -73,7 +73,7 @@ public void Custom_token_replacer_can_expand_option_argument_values()
                      })
                      .Build();
 
-        var result = parser.Parse("-x @replace-me");
+        var result = command.Parse("-x @replace-me", config);
 
         result.Errors.Should().BeEmpty();
 
@@ -87,7 +87,7 @@ public void Custom_token_replacer_can_expand_subcommands_and_options_and_argumen
 
         var command = new RootCommand { new Command("subcommand") { option } };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = new[] { "subcommand", "-x", "123" };
@@ -96,7 +96,7 @@ public void Custom_token_replacer_can_expand_subcommands_and_options_and_argumen
                      })
                      .Build();
 
-        var result = parser.Parse("@replace-me");
+        var result = command.Parse("@replace-me", config);
 
         result.Errors.Should().BeEmpty();
 
@@ -110,7 +110,7 @@ public void Expanded_tokens_containing_whitespace_are_parsed_as_single_tokens()
 
         var command = new RootCommand { argument };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = new[] { "one two three" };
@@ -119,7 +119,7 @@ public void Expanded_tokens_containing_whitespace_are_parsed_as_single_tokens()
                      })
                      .Build();
 
-        var result = parser.Parse("@replace-me");
+        var result = command.Parse("@replace-me", config);
 
         result.GetValue(argument).Should().Be("one two three");
     }
@@ -131,7 +131,7 @@ public void Token_replacer_can_set_a_custom_error_message()
 
         var command = new RootCommand { argument };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = null;
@@ -140,7 +140,7 @@ public void Token_replacer_can_set_a_custom_error_message()
                      })
                      .Build();
 
-        var result = parser.Parse("@replace-me");
+        var result = command.Parse("@replace-me", config);
 
         result.Errors
               .Should()
@@ -154,7 +154,7 @@ public void When_token_replacer_returns_false_without_setting_an_error_message_t
 
         var command = new RootCommand { argument };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = null;
@@ -163,7 +163,7 @@ public void When_token_replacer_returns_false_without_setting_an_error_message_t
                      })
                      .Build();
 
-        var result = parser.Parse("@replace-me");
+        var result = command.Parse("@replace-me", config);
 
         result.Errors.Should().BeEmpty();
 
@@ -177,7 +177,7 @@ public void Token_replacer_will_delete_token_when_delegate_returns_true_and_sets
 
         var command = new RootCommand { argument };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = null;
@@ -186,7 +186,7 @@ public void Token_replacer_will_delete_token_when_delegate_returns_true_and_sets
                      })
                      .Build();
 
-        var result = parser.Parse("@replace-me");
+        var result = command.Parse("@replace-me", config);
 
         result.Errors.Should().BeEmpty();
 
@@ -200,7 +200,7 @@ public void Token_replacer_will_delete_token_when_delegate_returns_true_and_sets
 
         var command = new RootCommand { argument };
 
-        var parser = new CommandLineBuilder(command)
+        var config = new CommandLineBuilder(command)
                      .UseTokenReplacer((string tokenToReplace, out IReadOnlyList<string> tokens, out string message) =>
                      {
                          tokens = Array.Empty<string>();
@@ -209,7 +209,7 @@ public void Token_replacer_will_delete_token_when_delegate_returns_true_and_sets
                      })
                      .Build();
 
-        var result = parser.Parse("@replace-me");
+        var result = command.Parse("@replace-me", config);
 
         result.Errors.Should().BeEmpty();
 
diff --git a/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs b/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs
index 04bf66f321..c1fd66824a 100644
--- a/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs
+++ b/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs
@@ -34,7 +34,7 @@ public async Task Declaration_of_UseExceptionHandler_can_come_after_other_middle
         [Fact]
         public async Task UseExceptionHandler_catches_middleware_exceptions_and_writes_details_to_standard_error()
         {
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              new Command("the-command")
                          })
@@ -42,7 +42,7 @@ public async Task UseExceptionHandler_catches_middleware_exceptions_and_writes_d
                          .UseExceptionHandler()
                          .Build();
 
-            var resultCode = await parser.InvokeAsync("the-command", _console);
+            var resultCode = await config.InvokeAsync("the-command", _console);
 
             _console.Error.ToString().Should().Contain("Unhandled exception: System.Exception: oops!");
 
@@ -62,14 +62,14 @@ public async Task UseExceptionHandler_catches_command_handler_exceptions_and_set
 #pragma warning restore CS0162
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
                          .UseExceptionHandler()
                          .Build();
 
-            var resultCode = await parser.InvokeAsync("the-command", _console);
+            var resultCode = await config.InvokeAsync("the-command", _console);
 
             resultCode.Should().Be(1);
         }
@@ -87,14 +87,14 @@ public async Task UseExceptionHandler_catches_command_handler_exceptions_and_wri
 #pragma warning restore CS0162
             });
 
-            var parser = new CommandLineBuilder(new RootCommand
+            var config = new CommandLineBuilder(new RootCommand
                          {
                              command
                          })
                          .UseExceptionHandler()
                          .Build();
 
-            await parser.InvokeAsync("the-command", _console);
+            await config.InvokeAsync("the-command", _console);
 
             _console.Error.ToString().Should().Contain("System.Exception: oops!");
         }
diff --git a/src/System.CommandLine.Tests/UseHelpTests.cs b/src/System.CommandLine.Tests/UseHelpTests.cs
index a3cebae75d..f9aa48c8a2 100644
--- a/src/System.CommandLine.Tests/UseHelpTests.cs
+++ b/src/System.CommandLine.Tests/UseHelpTests.cs
@@ -25,7 +25,7 @@ public async Task UseHelp_writes_help_for_the_specified_command()
             var subcommand = new Command("subcommand");
             command.Subcommands.Add(subcommand);
 
-            var parser =
+            var config =
                 new CommandLineBuilder(new RootCommand
                     {
                         command
@@ -33,7 +33,7 @@ public async Task UseHelp_writes_help_for_the_specified_command()
                     .UseHelp()
                     .Build();
 
-            var result = parser.Parse("command subcommand --help");
+            var result = command.Parse("command subcommand --help", config);
 
             await result.InvokeAsync(_console);
 
@@ -49,7 +49,7 @@ public async Task UseHelp_interrupts_execution_of_the_specified_command()
             subcommand.SetHandler(() => wasCalled = true);
             command.Subcommands.Add(subcommand);
 
-            var parser =
+            var config =
                 new CommandLineBuilder(new RootCommand
                     {
                         command
@@ -57,7 +57,7 @@ public async Task UseHelp_interrupts_execution_of_the_specified_command()
                     .UseHelp()
                     .Build();
 
-            await parser.InvokeAsync("command subcommand --help", _console);
+            await config.InvokeAsync("command subcommand --help", _console);
 
             wasCalled.Should().BeFalse();
         }
@@ -69,7 +69,7 @@ public async Task UseHelp_interrupts_execution_of_the_specified_command()
         [InlineData("/?")]
         public async Task UseHelp_accepts_default_values(string value)
         {
-            var parser =
+            var config =
                 new CommandLineBuilder(new RootCommand
                     {
                         new Command("command")
@@ -77,7 +77,7 @@ public async Task UseHelp_accepts_default_values(string value)
                     .UseHelp()
                     .Build();
 
-            await parser.InvokeAsync($"command {value}", _console);
+            await config.InvokeAsync($"command {value}", _console);
 
             _console.Should().ShowHelp();
         }
@@ -88,7 +88,7 @@ public async Task UseHelp_does_not_display_when_option_defined_with_same_alias()
             var command = new Command("command");
             command.Options.Add(new Option<bool>("-h"));
             
-            var parser =
+            var config =
                 new CommandLineBuilder(new RootCommand
                     {
                         command
@@ -96,7 +96,7 @@ public async Task UseHelp_does_not_display_when_option_defined_with_same_alias()
                     .UseHelp()
                     .Build();
 
-            var result = parser.Parse("command -h");
+            var result = command.Parse("command -h", config);
 
             await result.InvokeAsync(_console);
 
@@ -106,11 +106,12 @@ public async Task UseHelp_does_not_display_when_option_defined_with_same_alias()
         [Fact]
         public void There_are_no_parse_errors_when_help_is_invoked_on_root_command()
         {
-            var parser = new CommandLineBuilder()
+            RootCommand rootCommand = new ();
+            var config = new CommandLineBuilder(rootCommand)
                 .UseHelp()
                 .Build();
 
-            var result = parser.Parse("-h");
+            var result = rootCommand.Parse("-h", config);
 
             result.Errors
                   .Should()
@@ -125,11 +126,11 @@ public void There_are_no_parse_errors_when_help_is_invoked_on_subcommand()
                 new Command("subcommand")
             };
 
-            var parser = new CommandLineBuilder(root)
+            var config = new CommandLineBuilder(root)
                          .UseHelp()
                          .Build();
 
-            var result = parser.Parse("subcommand -h");
+            var result = root.Parse("subcommand -h", config);
 
             result.Errors
                   .Should()
@@ -144,11 +145,11 @@ public void There_are_no_parse_errors_when_help_is_invoked_on_a_command_with_sub
                 new Command("subcommand")
             };
 
-            var parser = new CommandLineBuilder(root)
+            var config = new CommandLineBuilder(root)
                          .UseHelp()
                          .Build();
 
-            var result = parser.Parse("-h");
+            var result = root.Parse("-h", config);
 
             result.Errors.Should().BeEmpty();
         }
@@ -164,10 +165,10 @@ public void There_are_no_parse_errors_when_help_is_invoked_on_a_command_with_req
                 },
             };
 
-            var result = new CommandLineBuilder(command)
+            var configuration = new CommandLineBuilder(command)
                          .UseHelp()
-                         .Build()
-                         .Parse("-h");
+                         .Build();
+            var result = command.Parse("-h", configuration);
 
             result.Errors.Should().BeEmpty();
         }
@@ -182,12 +183,12 @@ public void UseHelp_can_be_called_more_than_once_on_the_same_CommandLineBuilder(
                 new Command("inner")
             };
 
-            var parser = new CommandLineBuilder(root)
+            var config = new CommandLineBuilder(root)
                          .UseHelp()
                          .UseHelp()
                          .Build();
 
-            parser.Invoke(commandline, _console);
+            config.Invoke(commandline, _console);
 
             _console.Should().ShowHelp();
         }
@@ -202,13 +203,13 @@ public void UseHelp_can_be_called_more_than_once_on_the_same_command_with_differ
                 new Command("inner")
             };
 
-            var parser = new CommandLineBuilder(root)
+            var config = new CommandLineBuilder(root)
                          .UseHelp()
                          .Build();
 
             var console1 = new TestConsole();
 
-            parser.Invoke(commandline, console1);
+            config.Invoke(commandline, console1);
 
             console1.Should().ShowHelp();
 
@@ -227,12 +228,12 @@ public void UseHelp_can_be_called_more_than_once_on_the_same_command_with_differ
         [InlineData("--confused")]
         public async Task UseHelp_with_custom_aliases_uses_aliases(string helpAlias)
         {
-            var parser =
-                new CommandLineBuilder()
+            var config =
+                new CommandLineBuilder(new RootCommand())
                     .UseHelp("/lost", "--confused")
                     .Build();
 
-            await parser.InvokeAsync(helpAlias, _console);
+            await config.InvokeAsync(helpAlias, _console);
 
             _console.Should().ShowHelp();
         }
@@ -245,12 +246,12 @@ public async Task UseHelp_with_custom_aliases_uses_aliases(string helpAlias)
         [InlineData("/?")]
         public async Task UseHelp_with_custom_aliases_default_aliases_replaced(string helpAlias)
         {
-            var parser =
-                new CommandLineBuilder()
+            var config =
+                new CommandLineBuilder(new RootCommand())
                     .UseHelp("--confused")
                     .Build();
 
-            await parser.InvokeAsync(helpAlias, _console);
+            await config.InvokeAsync(helpAlias, _console);
 
             _console.Out.ToString().Should().Be("");
         }
@@ -269,7 +270,7 @@ public void Individual_symbols_can_be_customized()
                 argument
             };
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                          .UseHelp(ctx =>
                          {
                              ctx.HelpBuilder.CustomizeSymbol(subcommand, secondColumnText: "The custom command description");
@@ -279,7 +280,7 @@ public void Individual_symbols_can_be_customized()
                          .Build();
 
             var console = new TestConsole();
-            parser.Invoke("-h", console);
+            config.Invoke("-h", console);
 
             console.Out
                    .ToString()
@@ -292,12 +293,12 @@ public void Individual_symbols_can_be_customized()
         [Fact]
         public void Help_sections_can_be_replaced()
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .UseHelp(ctx => ctx.HelpBuilder.CustomizeLayout(CustomLayout))
                          .Build();
 
             var console = new TestConsole();
-            parser.Invoke("-h", console);
+            config.Invoke("-h", console);
 
             console.Out.ToString().Should().Be($"one{NewLine}{NewLine}two{NewLine}{NewLine}three{NewLine}{NewLine}{NewLine}");
 
@@ -313,12 +314,12 @@ IEnumerable<Action<HelpContext>> CustomLayout(HelpContext _)
         public void Help_sections_can_be_supplemented()
         {
             var command = new RootCommand("hello");
-            var parser = new CommandLineBuilder(command)
+            var config = new CommandLineBuilder(command)
                          .UseHelp(ctx => ctx.HelpBuilder.CustomizeLayout(CustomLayout))
                          .Build();
 
             var console = new TestConsole();
-            parser.Invoke("-h", console);
+            config.Invoke("-h", console);
 
             var output = console.Out.ToString();
             var defaultHelp = GetDefaultHelp(command);
@@ -351,7 +352,7 @@ public void Layout_can_be_composed_dynamically_based_on_context()
                 commandWithCustomHelp
             };
 
-            var parser = new CommandLineBuilder(command)
+            var config = new CommandLineBuilder(command)
                          .UseHelp(
                              ctx =>
                                  ctx.HelpBuilder
@@ -366,10 +367,10 @@ public void Layout_can_be_composed_dynamically_based_on_context()
                          .Build();
 
             var typicalOutput = new TestConsole();
-            parser.Invoke("typical -h", typicalOutput);
+            config.Invoke("typical -h", typicalOutput);
 
             var customOutput = new TestConsole();
-            parser.Invoke("custom -h", customOutput);
+            config.Invoke("custom -h", customOutput);
 
             typicalOutput.Out.ToString().Should().Be(GetDefaultHelp(commandWithTypicalHelp, false));
             customOutput.Out.ToString().Should().Be($"Custom layout!{NewLine}{NewLine}{GetDefaultHelp(commandWithCustomHelp, false)}");
@@ -383,12 +384,12 @@ public void Help_default_sections_can_be_wrapped()
                 new Option<string>("--option", "option description")
             };
 
-            var parser = new CommandLineBuilder(command)
+            var config = new CommandLineBuilder(command)
                          .UseHelp(maxWidth: 30)
                          .Build();
 
             var console = new TestConsole();
-            parser.Invoke("test -h", console);
+            config.Invoke("test -h", console);
 
             string result = console.Out.ToString();
             result.Should().Be(
@@ -407,12 +408,12 @@ public void Help_default_sections_can_be_wrapped()
         [Fact]
         public void Help_customized_sections_can_be_wrapped()
         {
-            var parser = new CommandLineBuilder()
+            var config = new CommandLineBuilder(new RootCommand())
                          .UseHelp(ctx => ctx.HelpBuilder.CustomizeLayout(CustomLayout), maxWidth: 10)
                          .Build();
 
             var console = new TestConsole();
-            parser.Invoke("-h", console);
+            config.Invoke("-h", console);
 
             string result = console.Out.ToString();
             result.Should().Be($"  123  123{NewLine}  456  456{NewLine}  78   789{NewLine}       0{NewLine}{NewLine}{NewLine}");
@@ -427,11 +428,11 @@ private string GetDefaultHelp(Command command, bool trimOneNewline = true)
         {
             var console = new TestConsole();
 
-            var parser = new CommandLineBuilder(command)
+            var config = new CommandLineBuilder(command)
                          .UseHelp()
                          .Build();
 
-            parser.Invoke("-h", console);
+            config.Invoke("-h", console);
 
             var output = console.Out.ToString();
 
diff --git a/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs b/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs
index dfcb33a720..7ca8b1b9a0 100644
--- a/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs
+++ b/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs
@@ -20,16 +20,16 @@ public void Parse_error_reporting_reports_error_when_help_is_used_and_required_s
                 new Command("inner")
             };
 
-            var parser = new CommandLineBuilder(root)
+            var config = new CommandLineBuilder(root)
                          .UseParseErrorReporting()
                          .UseHelp()
                          .Build();
 
-            var parseResult = parser.Parse("");
+            var parseResult = root.Parse("", config);
 
             parseResult.Errors.Should().NotBeEmpty();
 
-            var result = parser.Invoke("");
+            var result = config.Invoke("");
 
             result.Should().Be(1);
         }
@@ -42,11 +42,11 @@ public void Parse_error_uses_custom_error_result_code()
                 new Command("inner")
             };
 
-            var parser = new CommandLineBuilder(root)
+            var config = new CommandLineBuilder(root)
                          .UseParseErrorReporting(errorExitCode: 42)
                          .Build();
 
-            int result = parser.Invoke("");
+            int result = config.Invoke("");
 
             result.Should().Be(42);
         }
diff --git a/src/System.CommandLine.Tests/VersionOptionTests.cs b/src/System.CommandLine.Tests/VersionOptionTests.cs
index fcebf7c1f9..ad3cf38eee 100644
--- a/src/System.CommandLine.Tests/VersionOptionTests.cs
+++ b/src/System.CommandLine.Tests/VersionOptionTests.cs
@@ -21,13 +21,13 @@ public class VersionOptionTests
         [Fact]
         public async Task When_the_version_option_is_specified_then_the_version_is_written_to_standard_out()
         {
-            var parser = new CommandLineBuilder()
+            var configuration = new CommandLineBuilder(new RootCommand())
                          .UseVersionOption()
                          .Build();
 
             var console = new TestConsole();
 
-            await parser.InvokeAsync("--version", console);
+            await configuration.InvokeAsync("--version", console);
 
             console.Out.ToString().Should().Be($"{version}{NewLine}");
         }
@@ -39,13 +39,13 @@ public async Task When_the_version_option_is_specified_then_invocation_is_short_
             var rootCommand = new RootCommand();
             rootCommand.SetHandler(() => wasCalled = true);
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var config = new CommandLineBuilder(rootCommand)
                          .UseVersionOption()
                          .Build();
 
             var console = new TestConsole();
 
-            await parser.InvokeAsync("--version", console);
+            await config.InvokeAsync("--version", console);
 
             wasCalled.Should().BeFalse();
         }
@@ -53,14 +53,14 @@ public async Task When_the_version_option_is_specified_then_invocation_is_short_
         [Fact]
         public async Task Version_option_appears_in_help()
         {
-            var parser = new CommandLineBuilder()
+            var configuration = new CommandLineBuilder(new RootCommand())
                          .UseHelp()
                          .UseVersionOption()
                          .Build();
 
             var console = new TestConsole();
 
-            await parser.InvokeAsync("--help", console);
+            await configuration.InvokeAsync("--help", console);
 
             console.Out
                    .ToString()
@@ -77,13 +77,13 @@ public async Task When_the_version_option_is_specified_and_there_are_default_opt
             };
             rootCommand.SetHandler(() => { });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var configuration = new CommandLineBuilder(rootCommand)
                 .UseVersionOption()
                 .Build();
 
             var console = new TestConsole();
 
-            await parser.InvokeAsync("--version", console);
+            await configuration.InvokeAsync("--version", console);
 
             console.Out.ToString().Should().Be($"{version}{NewLine}");
         }
@@ -97,13 +97,13 @@ public async Task When_the_version_option_is_specified_and_there_are_default_arg
             };
             rootCommand.SetHandler(() => { });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var configuration = new CommandLineBuilder(rootCommand)
                 .UseVersionOption()
                 .Build();
 
             var console = new TestConsole();
 
-            await parser.InvokeAsync("--version", console);
+            await configuration.InvokeAsync("--version", console);
 
             console.Out.ToString().Should().Be($"{version}{NewLine}");
         }
@@ -122,11 +122,11 @@ public void Version_is_not_valid_with_other_tokens(string commandLine)
             };
             rootCommand.SetHandler(() => { });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var configuration = new CommandLineBuilder(rootCommand)
                 .UseVersionOption()
                 .Build();
 
-            var result = parser.Parse(commandLine);
+            var result = rootCommand.Parse(commandLine, configuration);
 
             result.Errors.Should().Contain(e => e.Message == "--version option cannot be combined with other arguments.");
         }
@@ -143,11 +143,11 @@ public void Version_option_is_not_added_to_subcommands()
             };
             rootCommand.SetHandler(() => { });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var configuration = new CommandLineBuilder(rootCommand)
                          .UseVersionOption()
                          .Build();
 
-            parser.Configuration
+            configuration
                   .RootCommand
                   .Subcommands
                   .Single(c => c.Name == "subcommand")
@@ -163,14 +163,14 @@ public async Task Version_not_added_if_it_exists()
             // real world scenarios - invocation can be invoked twice
             // or the author may have their own version switch but
             // still want other defaults.
-            var parser = new CommandLineBuilder()
+            var configuration = new CommandLineBuilder(new RootCommand())
                          .UseVersionOption()
                          .UseVersionOption()
                          .Build();
 
             var console = new TestConsole();
 
-            await parser.InvokeAsync("--version", console);
+            await configuration.InvokeAsync("--version", console);
 
             console.Out.ToString().Should().Be($"{version}{NewLine}");
         }
@@ -178,16 +178,16 @@ public async Task Version_not_added_if_it_exists()
         [Fact]
         public async Task Version_can_specify_additional_alias()
         {
-            var parser = new CommandLineBuilder()
+            var configuration = new CommandLineBuilder(new RootCommand())
                          .UseVersionOption("-v", "-version")
                          .Build();
 
             var console = new TestConsole();
-            await parser.InvokeAsync("-v", console);
+            await configuration.InvokeAsync("-v", console);
             console.Out.ToString().Should().Be($"{version}{NewLine}");
 
             console = new TestConsole();
-            await parser.InvokeAsync("-version", console);
+            await configuration.InvokeAsync("-version", console);
             console.Out.ToString().Should().Be($"{version}{NewLine}");
         }
 
@@ -202,11 +202,11 @@ public void Version_is_not_valid_with_other_tokens_uses_custom_alias()
             };
             rootCommand.SetHandler(() => { });
 
-            var parser = new CommandLineBuilder(rootCommand)
+            var configuration = new CommandLineBuilder(rootCommand)
                          .UseVersionOption("-v")
                          .Build();
 
-            var result = parser.Parse("-v subcommand");
+            var result = rootCommand.Parse("-v subcommand", configuration);
 
             result.Errors.Should().ContainSingle(e => e.Message == "-v option cannot be combined with other arguments.");
         }
diff --git a/src/System.CommandLine/Argument.cs b/src/System.CommandLine/Argument.cs
index b9bf36e259..ae5276b1b3 100644
--- a/src/System.CommandLine/Argument.cs
+++ b/src/System.CommandLine/Argument.cs
@@ -141,22 +141,5 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
 
         /// <inheritdoc />
         string IValueDescriptor.ValueName => Name;
-
-        /// <summary>
-        /// Parses a command line string value using the argument.
-        /// </summary>
-        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
-        /// <param name="commandLine">A command line string to parse, which can include spaces and quotes equivalent to what can be entered into a terminal.</param>
-        /// <returns>A parse result describing the outcome of the parse operation.</returns>
-        public ParseResult Parse(string commandLine) =>
-            this.GetOrCreateDefaultSimpleParser().Parse(commandLine);
-
-        /// <summary>
-        /// Parses a command line string value using the argument.
-        /// </summary>
-        /// <param name="args">The string arguments to parse.</param>
-        /// <returns>A parse result describing the outcome of the parse operation.</returns>
-        public ParseResult Parse(string[] args) =>
-            this.GetOrCreateDefaultSimpleParser().Parse(args);
     }
 }
diff --git a/src/System.CommandLine/Builder/CommandLineBuilder.cs b/src/System.CommandLine/Builder/CommandLineBuilder.cs
index 5270370d71..83b7e617c6 100644
--- a/src/System.CommandLine/Builder/CommandLineBuilder.cs
+++ b/src/System.CommandLine/Builder/CommandLineBuilder.cs
@@ -12,10 +12,10 @@ namespace System.CommandLine
     /// <summary>
     /// Enables composition of command line configurations.
     /// </summary>
-    public class CommandLineBuilder 
+    public partial class CommandLineBuilder 
     {
         /// <inheritdoc cref="CommandLineConfiguration.EnablePosixBundling"/>
-        internal bool EnablePosixBundling = true;
+        internal bool EnablePosixBundlingFlag = true;
 
         /// <inheritdoc cref="CommandLineConfiguration.EnableTokenReplacement"/>
         internal bool EnableTokenReplacement = true;
@@ -24,7 +24,7 @@ public class CommandLineBuilder
         internal int? ParseErrorReportingExitCode;
 
         /// <inheritdoc cref="CommandLineConfiguration.EnableDirectives"/>
-        internal bool EnableDirectives = true;
+        internal bool EnableDirectivesFlag = true;
 
         /// <inheritdoc cref="CommandLineConfiguration.EnableEnvironmentVariableDirective"/>
         internal bool EnableEnvironmentVariableDirective;
@@ -51,9 +51,9 @@ public class CommandLineBuilder
         private Func<BindingContext, HelpBuilder>? _helpBuilderFactory;
 
         /// <param name="rootCommand">The root command of the application.</param>
-        public CommandLineBuilder(Command? rootCommand = null)
+        public CommandLineBuilder(Command rootCommand)
         {
-            Command = rootCommand ?? new RootCommand();
+            Command = rootCommand ?? throw new ArgumentNullException(nameof(rootCommand));
         }
 
         /// <summary>
@@ -94,25 +94,24 @@ HelpBuilder CreateHelpBuilder(BindingContext bindingContext)
         /// <summary>
         /// Creates a parser based on the configuration of the command line builder.
         /// </summary>
-        public Parser Build() =>
-            new(
-                new CommandLineConfiguration(
-                    Command,
-                    enablePosixBundling: EnablePosixBundling,
-                    enableDirectives: EnableDirectives,
-                    enableTokenReplacement: EnableTokenReplacement,
-                    enableEnvironmentVariableDirective: EnableEnvironmentVariableDirective,
-                    parseDirectiveExitCode: ParseDirectiveExitCode,
-                    enableSuggestDirective: EnableSuggestDirective,
-                    parseErrorReportingExitCode: ParseErrorReportingExitCode,
-                    maxLevenshteinDistance: MaxLevenshteinDistance,
-                    exceptionHandler: ExceptionHandler,
-                    processTerminationTimeout: ProcessTerminationTimeout,
-                    middlewarePipeline: _middlewareList is null
-                                            ? Array.Empty<InvocationMiddleware>()
-                                            : GetMiddleware(),
-                    helpBuilderFactory: GetHelpBuilderFactory(),
-                    tokenReplacer: TokenReplacer));
+        public CommandLineConfiguration Build() =>
+            new (
+                Command,
+                enablePosixBundling: EnablePosixBundlingFlag,
+                enableDirectives: EnableDirectivesFlag,
+                enableTokenReplacement: EnableTokenReplacement,
+                enableEnvironmentVariableDirective: EnableEnvironmentVariableDirective,
+                parseDirectiveExitCode: ParseDirectiveExitCode,
+                enableSuggestDirective: EnableSuggestDirective,
+                parseErrorReportingExitCode: ParseErrorReportingExitCode,
+                maxLevenshteinDistance: MaxLevenshteinDistance,
+                exceptionHandler: ExceptionHandler,
+                processTerminationTimeout: ProcessTerminationTimeout,
+                middlewarePipeline: _middlewareList is null
+                                        ? Array.Empty<InvocationMiddleware>()
+                                        : GetMiddleware(),
+                helpBuilderFactory: GetHelpBuilderFactory(),
+                tokenReplacer: TokenReplacer);
 
         private IReadOnlyList<InvocationMiddleware> GetMiddleware()
         {
@@ -125,9 +124,6 @@ private IReadOnlyList<InvocationMiddleware> GetMiddleware()
             return result;
         }
 
-        internal void AddMiddleware(InvocationMiddleware middleware, MiddlewareOrder order)
-            => AddMiddleware(middleware, (int)order);
-
         internal void AddMiddleware(InvocationMiddleware middleware, MiddlewareOrderInternal order)
             => AddMiddleware(middleware, (int)order);
 
diff --git a/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs b/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs
index 12c7edef19..7318462005 100644
--- a/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs
+++ b/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs
@@ -9,59 +9,48 @@
 using System.CommandLine.Parsing;
 using System.IO;
 using System.Threading;
-using System.Threading.Tasks;
-using static System.Environment;
 using Process = System.CommandLine.Invocation.Process;
 
 namespace System.CommandLine
 {
-    /// <summary>
-    /// Provides extension methods for <see cref="CommandLineBuilder"/>.
-    /// </summary>
-    public static class CommandLineBuilderExtensions
+    public partial class CommandLineBuilder
     {
         /// <summary>
         /// Enables signaling and handling of process termination via a <see cref="CancellationToken"/> that can be passed to a <see cref="ICommandHandler"/> during invocation.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="timeout">
         /// Optional timeout for the command to process the exit cancellation.
         /// If not passed, a default timeout of 2 seconds is enforced.
         /// If positive value is passed - command is forcefully terminated after the timeout with exit code 130 (as if <see cref="CancelOnProcessTermination"/> was not called).
         /// Host enforced timeout for ProcessExit event cannot be extended - default is 2 seconds: https://docs.microsoft.com/en-us/dotnet/api/system.appdomain.processexit?view=net-6.0.
         /// </param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder CancelOnProcessTermination(
-            this CommandLineBuilder builder,
-            TimeSpan? timeout = null)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder CancelOnProcessTermination(TimeSpan? timeout = null)
         {
-            builder.ProcessTerminationTimeout = timeout ?? TimeSpan.FromSeconds(2);
+            ProcessTerminationTimeout = timeout ?? TimeSpan.FromSeconds(2);
 
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Enables the parser to recognize command line directives.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="value"><see langword="true" /> to enable directives. <see langword="false" /> to parse directive-like tokens in the same way as any other token.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
         /// <seealso href="/dotnet/standard/commandline/syntax#directives">Command-line directives</seealso> 
         /// <seealso cref="DirectiveCollection"/>
-        public static CommandLineBuilder EnableDirectives(
-            this CommandLineBuilder builder,
-            bool value = true)
+        public CommandLineBuilder EnableDirectives(bool value = true)
         {
-            builder.EnableDirectives = value;
-            return builder;
+            EnableDirectivesFlag = value;
+
+            return this;
         }
 
         /// <summary>
         /// Enables the parser to recognize and expand POSIX-style bundled options.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="value"><see langword="true"/> to parse POSIX bundles; otherwise, <see langword="false"/>.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
         /// <remarks>
         /// POSIX conventions recommend that single-character options be allowed to be specified together after a single <c>-</c> prefix. When <see cref="EnablePosixBundling"/> is set to <see langword="true"/>, the following command lines are equivalent:
         /// 
@@ -78,24 +67,21 @@ public static CommandLineBuilder EnableDirectives(
         /// </code>
         ///
         /// </remarks>
-        public static CommandLineBuilder EnablePosixBundling(
-            this CommandLineBuilder builder,
-            bool value = true)
+        public CommandLineBuilder EnablePosixBundling(bool value = true)
         {
-            builder.EnablePosixBundling = value;
-            return builder;
+            EnablePosixBundlingFlag = value;
+
+            return this;
         }
 
         /// <summary>
         /// Ensures that the application is registered with the <c>dotnet-suggest</c> tool to enable command line completions.
         /// </summary>
         /// <remarks>For command line completions to work, users must install the <c>dotnet-suggest</c> tool as well as the appropriate shim script for their shell.</remarks>
-        /// <param name="builder">A command line builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder RegisterWithDotnetSuggest(
-            this CommandLineBuilder builder)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder RegisterWithDotnetSuggest()
         {
-            builder.AddMiddleware(async (context, cancellationToken, next) =>
+            AddMiddleware(async (context, cancellationToken, next) =>
             {
                 var feature = new FeatureRegistration("dotnet-suggest-registration");
 
@@ -138,20 +124,18 @@ await feature.EnsureRegistered(async () =>
                 await next(context, cancellationToken);
             }, MiddlewareOrderInternal.RegisterWithDotnetSuggest);
 
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Enables the use of the <c>[env:key=value]</c> directive, allowing environment variables to be set from the command line during invocation.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseEnvironmentVariableDirective(
-            this CommandLineBuilder builder)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseEnvironmentVariableDirective()
         {
-            builder.EnableEnvironmentVariableDirective = true;
+            EnableEnvironmentVariableDirective = true;
 
-            return builder;
+            return this;
         }
 
         /// <summary>
@@ -172,12 +156,10 @@ public static CommandLineBuilder UseEnvironmentVariableDirective(
         ///     .CancelOnProcessTermination();
         /// </code>
         /// </remarks>
-        /// <param name="builder">A command line builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseDefaults(this CommandLineBuilder builder)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseDefaults()
         {
-            return builder
-                   .UseVersionOption()
+            return UseVersionOption()
                    .UseHelp()
                    .UseEnvironmentVariableDirective()
                    .UseParseDirective()
@@ -192,18 +174,16 @@ public static CommandLineBuilder UseDefaults(this CommandLineBuilder builder)
         /// <summary>
         /// Enables an exception handler to catch any unhandled exceptions thrown by a command handler during invocation.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="onException">A delegate that will be called when an exception is thrown by a command handler.</param>
         /// <param name="errorExitCode">The exit code to be used when an exception is thrown.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseExceptionHandler(
-            this CommandLineBuilder builder,
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseExceptionHandler(
             Action<Exception, InvocationContext>? onException = null,
             int? errorExitCode = null)
         {
-            builder.ExceptionHandler = onException ?? Default;
+            ExceptionHandler = onException ?? Default;
 
-            return builder;
+            return this;
 
             void Default(Exception exception, InvocationContext context)
             {
@@ -231,100 +211,82 @@ void Default(Exception exception, InvocationContext context)
         ///    /?
         /// </code>
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="maxWidth">Maximum output width for default help builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseHelp(this CommandLineBuilder builder, int? maxWidth = null)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseHelp(int? maxWidth = null)
         {
-            return builder.UseHelp(new HelpOption(), maxWidth);
+            return UseHelp(new HelpOption(), maxWidth);
         }
 
         /// <summary>
         /// Configures the application to show help when one of the specified option aliases are used on the command line.
         /// </summary>
         /// <remarks>The specified aliases will override the default values.</remarks>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="helpAliases">The set of aliases that can be specified on the command line to request help.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseHelp(
-            this CommandLineBuilder builder,
-            params string[] helpAliases)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseHelp(params string[] helpAliases)
         {
-            return builder.UseHelp(new HelpOption(helpAliases));
+            return UseHelp(new HelpOption(helpAliases));
         }
 
         /// <summary>
         /// Configures the application to show help when one of the specified option aliases are used on the command line.
         /// </summary>
         /// <remarks>The specified aliases will override the default values.</remarks>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="customize">A delegate that will be called to customize help if help is requested.</param>
         /// <param name="maxWidth">Maximum output width for default help builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseHelp(
-            this CommandLineBuilder builder,
-            Action<HelpContext> customize,
-            int? maxWidth = null)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseHelp(Action<HelpContext> customize, int? maxWidth = null)
         {
-            builder.CustomizeHelpLayout(customize);
+            CustomizeHelpLayout(customize);
 
-            if (builder.HelpOption is null)
+            if (HelpOption is null)
             {
-                builder.UseHelp(new HelpOption(), maxWidth);
+                UseHelp(new HelpOption(), maxWidth);
             }
 
-            return builder;
+            return this;
         }
 
-        internal static CommandLineBuilder UseHelp(
-            this CommandLineBuilder builder,
-            HelpOption helpOption,
-            int? maxWidth = null)
+        internal CommandLineBuilder UseHelp(HelpOption helpOption, int? maxWidth = null)
         {
-            if (builder.HelpOption is null)
+            if (HelpOption is null)
             {
-                builder.HelpOption = helpOption;
-                builder.Command.Options.Add(helpOption);
-                builder.MaxHelpWidth = maxWidth;
+                HelpOption = helpOption;
+
+                OverwriteOrAdd(Command, helpOption);
+
+                MaxHelpWidth = maxWidth;
             }
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Specifies an <see cref="HelpBuilder"/> to be used to format help output when help is requested.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="getHelpBuilder">A delegate that returns an instance of <see cref="HelpBuilder"/></param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static TBuilder UseHelpBuilder<TBuilder>(this TBuilder builder,
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseHelpBuilder(
             Func<BindingContext, HelpBuilder> getHelpBuilder)
-            where TBuilder : CommandLineBuilder
         {
-            if (builder is null)
-            {
-                throw new ArgumentNullException(nameof(builder));
-            }
-            builder.UseHelpBuilderFactory(getHelpBuilder);
-            return builder;
+            UseHelpBuilderFactory(getHelpBuilder);
+
+            return this;
         }
 
         /// <summary>
         /// Adds a middleware delegate to the invocation pipeline called before a command handler is invoked.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="middleware">A delegate that will be invoked before a call to a command handler.</param>
         /// <param name="order">A value indicating the order in which the added delegate will be invoked relative to others in the pipeline.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder AddMiddleware(
-            this CommandLineBuilder builder,
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder AddMiddleware(
             InvocationMiddleware middleware,
             MiddlewareOrder order = MiddlewareOrder.Default)
         {
-            builder.AddMiddleware(
-                middleware,
-                order);
+            AddMiddleware(middleware, (int)order);
 
-            return builder;
+            return this;
         }
 
         /// <summary>
@@ -332,74 +294,62 @@ public static CommandLineBuilder AddMiddleware(
         /// </summary>
         /// <param name="onInvoke">A delegate that will be invoked before a call to a command handler.</param>
         /// <param name="order">A value indicating the order in which the added delegate will be invoked relative to others in the pipeline.</param>
-        /// <param name="builder">A command line builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder AddMiddleware(
-            this CommandLineBuilder builder,
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder AddMiddleware(
             Action<InvocationContext> onInvoke,
             MiddlewareOrder order = MiddlewareOrder.Default)
         {
-            builder.AddMiddleware(async (context, cancellationToken, next) =>
+            return AddMiddleware(async (context, cancellationToken, next) =>
             {
                 onInvoke(context);
                 await next(context, cancellationToken);
             }, order);
-
-            return builder;
         }
 
         /// <summary>
         /// Enables the use of the <c>[parse]</c> directive, which when specified on the command line will short circuit normal command handling and display a diagram explaining the parse result for the command line input.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="errorExitCode">If the parse result contains errors, this exit code will be used when the process exits.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseParseDirective(
-            this CommandLineBuilder builder,
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseParseDirective(
             int errorExitCode = 1)
         {
-            builder.ParseDirectiveExitCode = errorExitCode;
+            ParseDirectiveExitCode = errorExitCode;
 
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Configures the command line to write error information to standard error when there are errors parsing command line input.
         /// </summary>
         /// <param name="errorExitCode">The exit code to use when parser errors occur.</param>
-        /// <param name="builder">A command line builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseParseErrorReporting(
-            this CommandLineBuilder builder,
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseParseErrorReporting(
             int errorExitCode = 1)
         {
-            builder.ParseErrorReportingExitCode = errorExitCode;
+            ParseErrorReportingExitCode = errorExitCode;
 
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Enables the use of the <c>[suggest]</c> directive which when specified in command line input short circuits normal command handling and writes a newline-delimited list of suggestions suitable for use by most shells to provide command line completions.
         /// </summary>
         /// <remarks>The <c>dotnet-suggest</c> tool requires the suggest directive to be enabled for an application to provide completions.</remarks>
-        /// <param name="builder">A command line builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseSuggestDirective(
-            this CommandLineBuilder builder)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseSuggestDirective()
         {
-            builder.EnableSuggestDirective = true;
+            EnableSuggestDirective = true;
 
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Configures the application to provide alternative suggestions when a parse error is detected.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="maxLevenshteinDistance">The maximum Levenshtein distance for suggestions based on detected typos in command line input.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseTypoCorrections(
-            this CommandLineBuilder builder,
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseTypoCorrections(
             int maxLevenshteinDistance = 3)
         {
             if (maxLevenshteinDistance <= 0)
@@ -407,61 +357,73 @@ public static CommandLineBuilder UseTypoCorrections(
                 throw new ArgumentOutOfRangeException(nameof(maxLevenshteinDistance));
             }
 
-            builder.MaxLevenshteinDistance = maxLevenshteinDistance;
+            MaxLevenshteinDistance = maxLevenshteinDistance;
 
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Specifies a delegate used to replace any token prefixed with <code>@</code> with zero or more other tokens, prior to parsing. 
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
         /// <param name="replaceToken">Replaces the specified token with any number of other tokens.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseTokenReplacer(
-            this CommandLineBuilder builder,
-            TryReplaceToken? replaceToken)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseTokenReplacer(TryReplaceToken? replaceToken)
         {
-            builder.TokenReplacer = replaceToken;
+            EnableTokenReplacement = replaceToken is not null;
+            TokenReplacer = replaceToken;
 
-            return builder;
+            return this;
         }
 
         /// <summary>
         /// Enables the use of a option (defaulting to the alias <c>--version</c>) which when specified in command line input will short circuit normal command handling and instead write out version information before exiting.
         /// </summary>
-        /// <param name="builder">A command line builder.</param>
-        /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
-        public static CommandLineBuilder UseVersionOption(
-            this CommandLineBuilder builder)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseVersionOption()
         {
-            if (builder.VersionOption is not null)
+            if (VersionOption is null)
             {
-                return builder;
+                OverwriteOrAdd(Command, VersionOption = new());
             }
 
-            builder.VersionOption = new ();
-            builder.Command.Options.Add(builder.VersionOption);
-
-            return builder;
+            return this;
         }
 
-        /// <inheritdoc cref="UseVersionOption(System.CommandLine.CommandLineBuilder)"/>
+        /// <inheritdoc cref="UseVersionOption()"/>
         /// <param name="aliases">One or more aliases to use instead of the default to signal that version information should be displayed.</param>
-        /// <param name="builder">A command line builder.</param>
-        public static CommandLineBuilder UseVersionOption(
-            this CommandLineBuilder builder,
-            params string[] aliases)
+        /// <returns>The reference to this <see cref="CommandLineBuilder"/> instance.</returns>
+        public CommandLineBuilder UseVersionOption(params string[] aliases)
         {
-            if (builder.VersionOption is not null)
+            if (VersionOption is null)
             {
-                return builder;
+                OverwriteOrAdd(Command, VersionOption = new(aliases));
             }
 
-            builder.VersionOption = new (aliases);
-            builder.Command.Options.Add(builder.VersionOption);
+            return this;
+        }
+
+        /// <summary>
+        /// Creating a config from Command might cause side effects for Command.
+        /// The config type may add Options to the Command.
+        /// Since single command can be parsed multiple times with different configs,
+        /// we need to handle it properly.
+        /// Ideally config should not mutate Command at all.
+        /// </summary>
+        private static void OverwriteOrAdd<T>(Command command, T option) where T : Option
+        {
+            if (command.HasOptions)
+            {
+                for (int i = 0; i < command.Options.Count; i++)
+                {
+                    if (command.Options[i] is T)
+                    {
+                        command.Options[i] = option;
+                        return;
+                    }
+                }
+            }
 
-            return builder;
+            command.Options.Add(option);
         }
     }
 }
diff --git a/src/System.CommandLine/Command.cs b/src/System.CommandLine/Command.cs
index 7bd9f12a43..170bef6a70 100644
--- a/src/System.CommandLine/Command.cs
+++ b/src/System.CommandLine/Command.cs
@@ -132,9 +132,24 @@ public void Add(Symbol symbol)
         /// <inheritdoc />
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-        internal Parser? ImplicitInvocationParser { get; set; }
+        /// <summary>
+        /// Parses an array strings using the command.
+        /// </summary>
+        /// <param name="args">The string arguments to parse.</param>
+        /// <param name="configuration">The configuration on which the parser's grammar and behaviors are based.</param>
+        /// <returns>A parse result describing the outcome of the parse operation.</returns>
+        public ParseResult Parse(IReadOnlyList<string> args, CommandLineConfiguration? configuration = null)
+            => Parser.Parse(this, args, configuration);
 
-        internal Parser? ImplicitSimpleParser { get; set; }
+        /// <summary>
+        /// Parses a command line string value using the command.
+        /// </summary>
+        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
+        /// <param name="commandLine">A command line string to parse, which can include spaces and quotes equivalent to what can be entered into a terminal.</param>
+        /// <param name="configuration">The configuration on which the parser's grammar and behaviors are based.</param>
+        /// <returns>A parse result describing the outcome of the parse operation.</returns>
+        public ParseResult Parse(string commandLine, CommandLineConfiguration? configuration = null)
+            => Parser.Parse(this, commandLine, configuration);
 
         /// <inheritdoc />
         public override IEnumerable<CompletionItem> GetCompletions(CompletionContext context)
diff --git a/src/System.CommandLine/CommandExtensions.cs b/src/System.CommandLine/CommandExtensions.cs
index b0ecd0af40..e1ade4092e 100644
--- a/src/System.CommandLine/CommandExtensions.cs
+++ b/src/System.CommandLine/CommandExtensions.cs
@@ -26,7 +26,7 @@ public static int Invoke(
             string[] args,
             IConsole? console = null)
         {
-            ParseResult parseResult = command.GetOrCreateDefaultInvocationParser().Parse(args);
+            ParseResult parseResult = command.Parse(args);
 
             return InvocationPipeline.Invoke(parseResult, console);
         }
@@ -59,7 +59,7 @@ public static Task<int> InvokeAsync(
             IConsole? console = null, 
             CancellationToken cancellationToken = default)
         {
-            ParseResult parseResult = command.GetOrCreateDefaultInvocationParser().Parse(args);
+            ParseResult parseResult = command.Parse(args);
 
             return InvocationPipeline.InvokeAsync(parseResult, console, cancellationToken);
         }
@@ -79,28 +79,5 @@ public static Task<int> InvokeAsync(
             IConsole? console = null,
             CancellationToken cancellationToken = default) =>
             command.InvokeAsync(CommandLineStringSplitter.Instance.Split(commandLine).ToArray(), console, cancellationToken);
-
-        /// <summary>
-        /// Parses an array strings using the specified command.
-        /// </summary>
-        /// <param name="command">The command to use to parse the command line input.</param>
-        /// <param name="args">The string arguments to parse.</param>
-        /// <returns>A parse result describing the outcome of the parse operation.</returns>
-        public static ParseResult Parse(
-            this Command command,
-            params string[] args) =>
-            command.GetOrCreateDefaultSimpleParser().Parse(args);
-
-        /// <summary>
-        /// Parses a command line string value using the specified command.
-        /// </summary>
-        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
-        /// <param name="command">The command to use to parse the command line input.</param>
-        /// <param name="commandLine">A command line string to parse, which can include spaces and quotes equivalent to what can be entered into a terminal.</param>
-        /// <returns>A parse result describing the outcome of the parse operation.</returns>
-        public static ParseResult Parse(
-            this Command command,
-            string commandLine) =>
-            command.GetOrCreateDefaultSimpleParser().Parse(commandLine);
     }
 }
\ No newline at end of file
diff --git a/src/System.CommandLine/CommandLineConfiguration.cs b/src/System.CommandLine/CommandLineConfiguration.cs
index 08c901b7a4..2d34c741c1 100644
--- a/src/System.CommandLine/CommandLineConfiguration.cs
+++ b/src/System.CommandLine/CommandLineConfiguration.cs
@@ -8,6 +8,8 @@
 using System.CommandLine.IO;
 using System.CommandLine.Parsing;
 using System.Linq;
+using System.Threading.Tasks;
+using System.Threading;
 
 namespace System.CommandLine
 {
@@ -110,6 +112,8 @@ internal CommandLineConfiguration(
             ExceptionHandler = exceptionHandler;
         }
 
+        public static CommandLineBuilder CreateBuilder(Command rootCommand) => new CommandLineBuilder(rootCommand);
+
         internal static HelpBuilder DefaultHelpBuilderFactory(BindingContext context, int? requestedMaxWidth = null)
         {
             int maxWidth = requestedMaxWidth ?? int.MaxValue;
@@ -163,6 +167,36 @@ private bool DefaultTokenReplacer(
         /// </summary>
         public Command RootCommand { get; }
 
+        /// <summary>
+        /// Parses a command line string value and invokes the handler for the indicated command.
+        /// </summary>
+        /// <returns>The exit code for the invocation.</returns>
+        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
+        public int Invoke(string commandLine, IConsole? console = null)
+            => RootCommand.Parse(commandLine, this).Invoke(console);
+
+        /// <summary>
+        /// Parses a command line string array and invokes the handler for the indicated command.
+        /// </summary>
+        /// <returns>The exit code for the invocation.</returns>
+        public int Invoke(string[] args, IConsole? console = null)
+            => RootCommand.Parse(args, this).Invoke(console);
+
+        /// <summary>
+        /// Parses a command line string value and invokes the handler for the indicated command.
+        /// </summary>
+        /// <returns>The exit code for the invocation.</returns>
+        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
+        public Task<int> InvokeAsync(string commandLine, IConsole? console = null, CancellationToken cancellationToken = default)
+            => RootCommand.Parse(commandLine, this).InvokeAsync(console, cancellationToken);
+
+        /// <summary>
+        /// Parses a command line string array and invokes the handler for the indicated command.
+        /// </summary>
+        /// <returns>The exit code for the invocation.</returns>
+        public Task<int> InvokeAsync(string[] args, IConsole? console = null, CancellationToken cancellationToken = default)
+            => RootCommand.Parse(args, this).InvokeAsync(console, cancellationToken);
+
         /// <summary>
         /// Throws an exception if the parser configuration is ambiguous or otherwise not valid.
         /// </summary>
diff --git a/src/System.CommandLine/Invocation/InvocationContext.cs b/src/System.CommandLine/Invocation/InvocationContext.cs
index 97482b6d03..03de4d652f 100644
--- a/src/System.CommandLine/Invocation/InvocationContext.cs
+++ b/src/System.CommandLine/Invocation/InvocationContext.cs
@@ -42,12 +42,7 @@ public IConsole Console
         /// <summary>
         /// Enables writing help output.
         /// </summary>
-        public HelpBuilder HelpBuilder => _helpBuilder ??= Parser.Configuration.HelpBuilderFactory(BindingContext);
-
-        /// <summary>
-        /// The parser used to create the <see cref="ParseResult"/>.
-        /// </summary>
-        public Parser Parser => ParseResult.Parser;
+        public HelpBuilder HelpBuilder => _helpBuilder ??= ParseResult.Configuration.HelpBuilderFactory(BindingContext);
 
         /// <summary>
         /// The parse result for the current invocation.
diff --git a/src/System.CommandLine/Invocation/InvocationPipeline.cs b/src/System.CommandLine/Invocation/InvocationPipeline.cs
index 621e93f6f4..9e609f3bb9 100644
--- a/src/System.CommandLine/Invocation/InvocationPipeline.cs
+++ b/src/System.CommandLine/Invocation/InvocationPipeline.cs
@@ -16,12 +16,12 @@ internal static async Task<int> InvokeAsync(ParseResult parseResult, IConsole? c
 
             using CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
 
-            Task<int> startedInvocation = parseResult.Handler is not null && context.Parser.Configuration.Middleware.Count == 0
+            Task<int> startedInvocation = parseResult.Handler is not null && parseResult.Configuration.Middleware.Count == 0
                 ? parseResult.Handler.InvokeAsync(context, cts.Token)
                 : InvokeHandlerWithMiddleware(context, cts.Token);
 
-            ProcessTerminationHandler? terminationHandler = parseResult.Parser.Configuration.ProcessTerminationTimeout.HasValue
-                ? new (cts, startedInvocation, parseResult.Parser.Configuration.ProcessTerminationTimeout.Value)
+            ProcessTerminationHandler? terminationHandler = parseResult.Configuration.ProcessTerminationTimeout.HasValue
+                ? new (cts, startedInvocation, parseResult.Configuration.ProcessTerminationTimeout.Value)
                 : null;
 
             try
@@ -39,9 +39,9 @@ internal static async Task<int> InvokeAsync(ParseResult parseResult, IConsole? c
                     return await firstCompletedTask; // return the result or propagate the exception
                 }
             }
-            catch (Exception ex) when (context.Parser.Configuration.ExceptionHandler is not null)
+            catch (Exception ex) when (parseResult.Configuration.ExceptionHandler is not null)
             {
-                context.Parser.Configuration.ExceptionHandler(ex, context);
+                parseResult.Configuration.ExceptionHandler(ex, context);
                 return context.ExitCode;
             }
             finally
@@ -65,16 +65,16 @@ internal static int Invoke(ParseResult parseResult, IConsole? console = null)
 
             try
             {
-                if (context.Parser.Configuration.Middleware.Count == 0 && parseResult.Handler is not null)
+                if (parseResult.Configuration.Middleware.Count == 0 && parseResult.Handler is not null)
                 {
                     return parseResult.Handler.Invoke(context);
                 }
 
                 return InvokeHandlerWithMiddleware(context); // kept in a separate method to avoid JITting
             }
-            catch (Exception ex) when (context.Parser.Configuration.ExceptionHandler is not null)
+            catch (Exception ex) when (parseResult.Configuration.ExceptionHandler is not null)
             {
-                context.Parser.Configuration.ExceptionHandler(ex, context);
+                parseResult.Configuration.ExceptionHandler(ex, context);
                 return context.ExitCode;
             }
 
@@ -90,8 +90,8 @@ static int InvokeHandlerWithMiddleware(InvocationContext context)
 
         private static InvocationMiddleware BuildInvocationChain(InvocationContext context, bool invokeAsync)
         {
-            var invocations = new List<InvocationMiddleware>(context.Parser.Configuration.Middleware.Count + 1);
-            invocations.AddRange(context.Parser.Configuration.Middleware);
+            var invocations = new List<InvocationMiddleware>(context.ParseResult.Configuration.Middleware.Count + 1);
+            invocations.AddRange(context.ParseResult.Configuration.Middleware);
 
             invocations.Add(async (invocationContext, cancellationToken, _) =>
             {
diff --git a/src/System.CommandLine/Invocation/ParseDirectiveResult.cs b/src/System.CommandLine/Invocation/ParseDirectiveResult.cs
index 0f212d6812..005c1844c7 100644
--- a/src/System.CommandLine/Invocation/ParseDirectiveResult.cs
+++ b/src/System.CommandLine/Invocation/ParseDirectiveResult.cs
@@ -14,7 +14,7 @@ internal static void Apply(InvocationContext context)
             context.Console.Out.WriteLine(parseResult.Diagram());
             context.ExitCode = parseResult.Errors.Count == 0
                                      ? 0
-                                     : context.Parser.Configuration.ParseDirectiveExitCode!.Value;
+                                     : context.ParseResult.Configuration.ParseDirectiveExitCode!.Value;
         }
     }
 }
diff --git a/src/System.CommandLine/Invocation/ParseErrorResult.cs b/src/System.CommandLine/Invocation/ParseErrorResult.cs
index 30432ddaad..72d4beb84e 100644
--- a/src/System.CommandLine/Invocation/ParseErrorResult.cs
+++ b/src/System.CommandLine/Invocation/ParseErrorResult.cs
@@ -20,7 +20,7 @@ internal static void Apply(InvocationContext context)
 
             context.Console.Error.WriteLine();
 
-            context.ExitCode = context.Parser.Configuration.ParseErrorReportingExitCode!.Value;
+            context.ExitCode = context.ParseResult.Configuration.ParseErrorReportingExitCode!.Value;
 
             context.Console.ResetTerminalForegroundColor();
 
diff --git a/src/System.CommandLine/Invocation/ServiceProvider.cs b/src/System.CommandLine/Invocation/ServiceProvider.cs
index 6610fcbc3c..2e96f4abe9 100644
--- a/src/System.CommandLine/Invocation/ServiceProvider.cs
+++ b/src/System.CommandLine/Invocation/ServiceProvider.cs
@@ -18,7 +18,7 @@ internal ServiceProvider(BindingContext bindingContext)
                         {
                             [typeof(ParseResult)] = _ => bindingContext.ParseResult,
                             [typeof(IConsole)] = _ => bindingContext.Console,
-                            [typeof(HelpBuilder)] = _ => bindingContext.ParseResult.Parser.Configuration.HelpBuilderFactory(bindingContext),
+                            [typeof(HelpBuilder)] = _ => bindingContext.ParseResult.Configuration.HelpBuilderFactory(bindingContext),
                             [typeof(BindingContext)] = _ => bindingContext
                         };
         }
diff --git a/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs b/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs
index 5e55deb76b..aeb404c51b 100644
--- a/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs
+++ b/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs
@@ -13,7 +13,7 @@ internal static void Apply(InvocationContext context, int position)
         {
             var commandLineToComplete = context.ParseResult.Tokens.LastOrDefault(t => t.Type != TokenType.Directive)?.Value ?? "";
 
-            var completionParseResult = context.Parser.Parse(commandLineToComplete);
+            var completionParseResult = context.ParseResult.RootCommandResult.Command.Parse(commandLineToComplete, context.ParseResult.Configuration);
 
             var completions = completionParseResult.GetCompletions(position);
 
diff --git a/src/System.CommandLine/Invocation/TypoCorrection.cs b/src/System.CommandLine/Invocation/TypoCorrection.cs
index efad1e8ce1..fcfc99c3bf 100644
--- a/src/System.CommandLine/Invocation/TypoCorrection.cs
+++ b/src/System.CommandLine/Invocation/TypoCorrection.cs
@@ -13,7 +13,7 @@ internal static void ProvideSuggestions(InvocationContext context)
         {
             ParseResult result = context.ParseResult;
             IConsole console = context.Console;
-            int maxLevenshteinDistance = context.Parser.Configuration.MaxLevenshteinDistance;
+            int maxLevenshteinDistance = result.Configuration.MaxLevenshteinDistance;
 
             var unmatchedTokens = result.UnmatchedTokens;
             for (var i = 0; i < unmatchedTokens.Count; i++)
diff --git a/src/System.CommandLine/Option.cs b/src/System.CommandLine/Option.cs
index f1a473de42..87292dee05 100644
--- a/src/System.CommandLine/Option.cs
+++ b/src/System.CommandLine/Option.cs
@@ -153,22 +153,5 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
                    .OrderBy(item => item.SortText.IndexOfCaseInsensitive(context.WordToComplete))
                    .ThenBy(symbol => symbol.Label, StringComparer.OrdinalIgnoreCase);
         }
-
-        /// <summary>
-        /// Parses a command line string value using the option.
-        /// </summary>
-        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
-        /// <param name="commandLine">A command line string to parse, which can include spaces and quotes equivalent to what can be entered into a terminal.</param>
-        /// <returns>A parse result describing the outcome of the parse operation.</returns>
-        public ParseResult Parse(string commandLine) =>
-            this.GetOrCreateDefaultSimpleParser().Parse(commandLine);
-
-        /// <summary>
-        /// Parses a command line string value using the option.
-        /// </summary>
-        /// <param name="args">The string options to parse.</param>
-        /// <returns>A parse result describing the outcome of the parse operation.</returns>
-        public ParseResult Parse(string[] args) =>
-            this.GetOrCreateDefaultSimpleParser().Parse(args);
     }
 }
diff --git a/src/System.CommandLine/ParseResult.cs b/src/System.CommandLine/ParseResult.cs
index 7c377a6d51..699f51dc77 100644
--- a/src/System.CommandLine/ParseResult.cs
+++ b/src/System.CommandLine/ParseResult.cs
@@ -4,8 +4,11 @@
 using System.Collections.Generic;
 using System.CommandLine.Binding;
 using System.CommandLine.Completions;
+using System.CommandLine.Invocation;
 using System.CommandLine.Parsing;
 using System.Linq;
+using System.Threading.Tasks;
+using System.Threading;
 
 namespace System.CommandLine
 {
@@ -22,7 +25,7 @@ public class ParseResult
         private ICommandHandler? _handler;
 
         internal ParseResult(
-            Parser parser,
+            CommandLineConfiguration configuration,
             CommandResult rootCommandResult,
             CommandResult commandResult,
             Dictionary<string, IReadOnlyList<string>>? directives,
@@ -32,7 +35,7 @@ internal ParseResult(
             string? commandLineText = null,
             ICommandHandler? handler = null)
         {
-            Parser = parser;
+            Configuration = configuration;
             _rootCommandResult = rootCommandResult;
             CommandResult = commandResult;
             _directives = directives;
@@ -65,9 +68,9 @@ internal ParseResult(
         public CommandResult CommandResult { get; }
 
         /// <summary>
-        /// The parser used to produce the parse result.
+        /// The configuration used to produce the parse result.
         /// </summary>
-        public Parser Parser { get; }
+        public CommandLineConfiguration Configuration { get; }
 
         /// <summary>
         /// Gets the root command result.
@@ -225,6 +228,22 @@ static string[] OptionsWithArgumentLimitReached(CommandResult commandResult) =>
                     .ToArray();
         }
 
+        /// <summary>
+        /// Invokes the appropriate command handler for a parsed command line input.
+        /// </summary>
+        /// <param name="console">A console to which output can be written. By default, <see cref="System.Console"/> is used.</param>
+        /// <param name="cancellationToken">A token that can be used to cancel an invocation.</param>
+        /// <returns>A task whose result can be used as a process exit code.</returns>
+        public Task<int> InvokeAsync(IConsole? console = null, CancellationToken cancellationToken = default)
+            => InvocationPipeline.InvokeAsync(this, console, cancellationToken);
+
+        /// <summary>
+        /// Invokes the appropriate command handler for a parsed command line input.
+        /// </summary>
+        /// <param name="console">A console to which output can be written. By default, <see cref="System.Console"/> is used.</param>
+        /// <returns>A value that can be used as a process exit code.</returns>
+        public int Invoke(IConsole? console = null) => InvocationPipeline.Invoke(this, console);
+
         internal ICommandHandler? Handler
         {
             get
diff --git a/src/System.CommandLine/Parsing/ParseOperation.cs b/src/System.CommandLine/Parsing/ParseOperation.cs
index dcac8ad0b7..8741adc7b6 100644
--- a/src/System.CommandLine/Parsing/ParseOperation.cs
+++ b/src/System.CommandLine/Parsing/ParseOperation.cs
@@ -50,7 +50,7 @@ private bool More(out TokenType currentTokenType)
             return result;
         }
 
-        internal ParseResult Parse(Parser parser)
+        internal ParseResult Parse()
         {
             ParseDirectives();
 
@@ -75,7 +75,7 @@ internal ParseResult Parse(Parser parser)
             }
 
             return new (
-                parser,
+                _configuration,
                 _rootCommandResult,
                 _innermostCommandResult,
                 _directives,
diff --git a/src/System.CommandLine/Parsing/ParseResultExtensions.cs b/src/System.CommandLine/Parsing/ParseResultExtensions.cs
index 89b7a67c02..e0ea375eee 100644
--- a/src/System.CommandLine/Parsing/ParseResultExtensions.cs
+++ b/src/System.CommandLine/Parsing/ParseResultExtensions.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections;
-using System.Collections.Generic;
 using System.CommandLine.Binding;
 using System.CommandLine.Invocation;
 using System.Linq;
@@ -17,30 +16,6 @@ namespace System.CommandLine.Parsing
     /// </summary>
     public static class ParseResultExtensions
     {
-        /// <summary>
-        /// Invokes the appropriate command handler for a parsed command line input.
-        /// </summary>
-        /// <param name="parseResult">A parse result on which the invocation is based.</param>
-        /// <param name="console">A console to which output can be written. By default, <see cref="System.Console"/> is used.</param>
-        /// <param name="cancellationToken">A token that can be used to cancel an invocation.</param>
-        /// <returns>A task whose result can be used as a process exit code.</returns>
-        public static Task<int> InvokeAsync(
-            this ParseResult parseResult,
-            IConsole? console = null,
-            CancellationToken cancellationToken = default) =>
-            InvocationPipeline.InvokeAsync(parseResult, console, cancellationToken);
-
-        /// <summary>
-        /// Invokes the appropriate command handler for a parsed command line input.
-        /// </summary>
-        /// <param name="parseResult">A parse result on which the invocation is based.</param>
-        /// <param name="console">A console to which output can be written. By default, <see cref="System.Console"/> is used.</param>
-        /// <returns>A value that can be used as a process exit code.</returns>
-        public static int Invoke(
-            this ParseResult parseResult,
-            IConsole? console = null) =>
-            InvocationPipeline.Invoke(parseResult, console);
-
         /// <summary>
         /// Formats a string explaining a parse result.
         /// </summary>
@@ -85,7 +60,6 @@ private static void Diagram(
                 builder.Append("!");
             }
 
-
             switch (symbolResult)
             {
                 case ArgumentResult argumentResult:
@@ -178,24 +152,5 @@ private static void Diagram(
                 }
             }
         }
-
-        /// <summary>
-        /// Indicates whether a given option is present in the parse result.
-        /// </summary>
-        /// <remarks>If the option has a default value defined, then <see langword="true"/> will be returned.</remarks>
-        /// <param name="parseResult">The parse result to check for the presence of the option.</param>
-        /// <param name="option">The option to check for the presence of.</param>
-        /// <returns><see langword="true"/> if the option is present; otherwise,  <see langword="false"/>.</returns>
-        public static bool HasOption(
-            this ParseResult parseResult,
-            Option option)
-        {
-            if (parseResult is null)
-            {
-                throw new ArgumentNullException(nameof(parseResult));
-            }
-
-            return parseResult.FindResultFor(option) is { };
-        }
     }
 }
diff --git a/src/System.CommandLine/Parsing/Parser.cs b/src/System.CommandLine/Parsing/Parser.cs
index 61046b2f90..a6fba6501d 100644
--- a/src/System.CommandLine/Parsing/Parser.cs
+++ b/src/System.CommandLine/Parsing/Parser.cs
@@ -2,56 +2,68 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
+using System.Linq;
 
 namespace System.CommandLine.Parsing
 {
     /// <summary>
     /// Parses command line input.
     /// </summary>
-    public class Parser
+    public static class Parser
     {
-        /// <param name="configuration">The configuration on which the parser's grammar and behaviors are based.</param>
-        /// <exception cref="ArgumentNullException"></exception>
-        public Parser(CommandLineConfiguration configuration)
-        {
-            Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
-        }
-
-        /// <param name="command">The root command for the parser.</param>
-        public Parser(Command command) : this(new CommandLineConfiguration(command))
-        {
-        }
-
         /// <summary>
-        /// Gets the configuration on which the parser's grammar and behaviors are based.
+        /// Parses a list of arguments.
         /// </summary>
-        public CommandLineConfiguration Configuration { get; }
+        /// <param name="command">The command to use to parse the command line input.</param>
+        /// <param name="args">The string array typically passed to a program's <c>Main</c> method.</param>
+        /// <param name="configuration">The configuration on which the parser's grammar and behaviors are based.</param>
+        /// <returns>A <see cref="ParseResult"/> providing details about the parse operation.</returns>
+        public static ParseResult Parse(Command command, IReadOnlyList<string> args, CommandLineConfiguration? configuration = null)
+            => Parse(command, args, null, configuration);
 
         /// <summary>
-        /// Parses a list of arguments.
+        /// Parses a command line string.
         /// </summary>
-        /// <param name="arguments">The string array typically passed to a program's <c>Main</c> method.</param>
-        /// <param name="rawInput">The complete command line input prior to splitting and tokenization. This input is not typically available when the parser is called from <c>Program.Main</c>. It is primarily used when calculating completions via the <c>dotnet-suggest</c> tool.</param>
+        /// <param name="command">The command to use to parse the command line input.</param>
+        /// <param name="commandLine">The complete command line input prior to splitting and tokenization. This input is not typically available when the parser is called from <c>Program.Main</c>. It is primarily used when calculating completions via the <c>dotnet-suggest</c> tool.</param>
+        /// <param name="configuration">The configuration on which the parser's grammar and behaviors are based.</param>
+        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
         /// <returns>A <see cref="ParseResult"/> providing details about the parse operation.</returns>
-        public ParseResult Parse(
-            IReadOnlyList<string>? arguments,
-            string? rawInput = null)
+        public static ParseResult Parse(Command command, string commandLine, CommandLineConfiguration? configuration = null)
         {
-            arguments ??= Array.Empty<string>();
+            var splitter = CommandLineStringSplitter.Instance;
+
+            var readOnlyCollection = splitter.Split(commandLine).ToArray();
+
+            return Parse(command, readOnlyCollection, commandLine, configuration);
+        }
+
+        private static ParseResult Parse(
+            Command command,
+            IReadOnlyList<string> arguments,
+            string? rawInput,
+            CommandLineConfiguration? configuration)
+        {
+            if (arguments is null)
+            {
+                throw new ArgumentNullException(nameof(arguments));
+            }
+
+            configuration ??= CommandLineConfiguration.CreateBuilder(command).UseDefaults().Build();
 
             arguments.Tokenize(
-                Configuration,
+                configuration,
                 inferRootCommand: rawInput is not null,
                 out List<Token> tokens,
                 out List<string>? tokenizationErrors);
 
             var operation = new ParseOperation(
                 tokens,
-                Configuration,
+                configuration,
                 tokenizationErrors,
                 rawInput);
 
-            return operation.Parse(this);
+            return operation.Parse();
         }
     }
 }
diff --git a/src/System.CommandLine/Parsing/ParserExtensions.cs b/src/System.CommandLine/Parsing/ParserExtensions.cs
deleted file mode 100644
index 85cf6c9d55..0000000000
--- a/src/System.CommandLine/Parsing/ParserExtensions.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace System.CommandLine.Parsing
-{
-    /// <summary>
-    /// Provides extension methods for parsers.
-    /// </summary>
-    public static class ParserExtensions
-    {
-        /// <summary>
-        /// Parses a command line string value and invokes the handler for the indicated command.
-        /// </summary>
-        /// <returns>The exit code for the invocation.</returns>
-        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
-        public static int Invoke(
-            this Parser parser,
-            string commandLine,
-            IConsole? console = null) =>
-            parser.Invoke(CommandLineStringSplitter.Instance.Split(commandLine).ToArray(), console);
-
-        /// <summary>
-        /// Parses a command line string array and invokes the handler for the indicated command.
-        /// </summary>
-        /// <returns>The exit code for the invocation.</returns>
-        public static int Invoke(
-            this Parser parser,
-            string[] args,
-            IConsole? console = null) =>
-            parser.Parse(args).Invoke(console);
-
-        /// <summary>
-        /// Parses a command line string value and invokes the handler for the indicated command.
-        /// </summary>
-        /// <returns>The exit code for the invocation.</returns>
-        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
-        public static Task<int> InvokeAsync(
-            this Parser parser,
-            string commandLine,
-            IConsole? console = null,
-            CancellationToken cancellationToken = default) =>
-            parser.InvokeAsync(CommandLineStringSplitter.Instance.Split(commandLine).ToArray(), console, cancellationToken);
-
-        /// <summary>
-        /// Parses a command line string array and invokes the handler for the indicated command.
-        /// </summary>
-        /// <returns>The exit code for the invocation.</returns>
-        public static Task<int> InvokeAsync(
-            this Parser parser,
-            string[] args,
-            IConsole? console = null,
-            CancellationToken cancellationToken = default) =>
-            parser.Parse(args).InvokeAsync(console, cancellationToken);
-
-        /// <summary>
-        /// Parses a command line string.
-        /// </summary>
-        /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
-        public static ParseResult Parse(
-            this Parser parser,
-            string commandLine)
-        {
-            var splitter = CommandLineStringSplitter.Instance;
-
-            var readOnlyCollection = splitter.Split(commandLine).ToArray();
-
-            return parser.Parse(readOnlyCollection, commandLine);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/System.CommandLine/SymbolExtensions.cs b/src/System.CommandLine/SymbolExtensions.cs
index 66c73f1157..875ebb437d 100644
--- a/src/System.CommandLine/SymbolExtensions.cs
+++ b/src/System.CommandLine/SymbolExtensions.cs
@@ -31,63 +31,5 @@ internal static IList<Argument> Arguments(this Symbol symbol)
                     throw new NotSupportedException();
             }
         }
-
-        internal static Parser GetOrCreateDefaultSimpleParser(this Symbol symbol)
-        {
-            var root = GetOrCreateRootCommand(symbol);
-
-            if (root.ImplicitSimpleParser is not { } parser)
-            {
-                parser = new Parser(new CommandLineConfiguration(root));
-                root.ImplicitSimpleParser = parser;
-            }
-
-            return parser;
-        }
-        
-        internal static Parser GetOrCreateDefaultInvocationParser(this Symbol symbol)
-        {
-            var root = GetOrCreateRootCommand(symbol);
-
-            if (root.ImplicitInvocationParser is not { } parser)
-            {
-                parser = new CommandLineBuilder(root).UseDefaults().Build();
-                root.ImplicitInvocationParser = parser;
-            }
-
-            return parser;
-        }
-
-        internal static Command GetOrCreateRootCommand(Symbol symbol)
-        {
-            if (symbol is Command cmd)
-            {
-                return cmd;
-            }
-
-            if (symbol.FirstParent is null)
-            {
-                return Create(symbol);
-            }
-
-            ParentNode? current = symbol.FirstParent;
-            while (current is not null)
-            {
-                if (current.Symbol is RootCommand root)
-                {
-                    return root;
-                }
-
-                current = current.Next;
-            }
-
-            return Create(symbol);
-
-            static RootCommand Create(Symbol notCommand)
-                => notCommand is Option option
-                    ? new RootCommand { option }
-                    // we know it's not a Command and not an Option, so it can only be an Argument
-                    : new RootCommand { (Argument)notCommand };
-        }
     }
 }
\ No newline at end of file