diff --git a/common/expr_factory.h b/common/expr_factory.h
index dd8e6ed25..c8a9b831f 100644
--- a/common/expr_factory.h
+++ b/common/expr_factory.h
@@ -179,9 +179,9 @@ class ExprFactory {
     return expr;
   }
 
-  Expr NewAccuIdent(ExprId id) {
-    return NewIdent(id, kAccumulatorVariableName);
-  }
+  absl::string_view AccuVarName() { return accu_var_; }
+
+  Expr NewAccuIdent(ExprId id) { return NewIdent(id, AccuVarName()); }
 
   template <typename Operand, typename Field,
             typename = std::enable_if_t<IsExprLike<Operand>::value>,
@@ -356,7 +356,10 @@ class ExprFactory {
   friend class MacroExprFactory;
   friend class ParserMacroExprFactory;
 
-  ExprFactory() = default;
+  ExprFactory() : accu_var_(kAccumulatorVariableName) {}
+  explicit ExprFactory(absl::string_view accu_var) : accu_var_(accu_var) {}
+
+  std::string accu_var_;
 };
 
 }  // namespace cel
diff --git a/parser/BUILD b/parser/BUILD
index 11cf95f85..aeb65342a 100644
--- a/parser/BUILD
+++ b/parser/BUILD
@@ -38,6 +38,7 @@ cc_library(
         "//base/ast_internal:expr",
         "//common:ast",
         "//common:constant",
+        "//common:expr",
         "//common:expr_factory",
         "//common:operators",
         "//common:source",
diff --git a/parser/macro.cc b/parser/macro.cc
index b11dca5db..db2fef502 100644
--- a/parser/macro.cc
+++ b/parser/macro.cc
@@ -103,7 +103,7 @@ absl::optional<Expr> ExpandAllMacro(MacroExprFactory& factory, Expr& target,
                               std::move(args[1]));
   auto result = factory.NewAccuIdent();
   return factory.NewComprehension(args[0].ident_expr().name(),
-                                  std::move(target), kAccumulatorVariableName,
+                                  std::move(target), factory.AccuVarName(),
                                   std::move(init), std::move(condition),
                                   std::move(step), std::move(result));
 }
@@ -136,7 +136,7 @@ absl::optional<Expr> ExpandExistsMacro(MacroExprFactory& factory, Expr& target,
                               std::move(args[1]));
   auto result = factory.NewAccuIdent();
   return factory.NewComprehension(args[0].ident_expr().name(),
-                                  std::move(target), kAccumulatorVariableName,
+                                  std::move(target), factory.AccuVarName(),
                                   std::move(init), std::move(condition),
                                   std::move(step), std::move(result));
 }
@@ -172,7 +172,7 @@ absl::optional<Expr> ExpandExistsOneMacro(MacroExprFactory& factory,
   auto result = factory.NewCall(CelOperator::EQUALS, factory.NewAccuIdent(),
                                 factory.NewIntConst(1));
   return factory.NewComprehension(args[0].ident_expr().name(),
-                                  std::move(target), kAccumulatorVariableName,
+                                  std::move(target), factory.AccuVarName(),
                                   std::move(init), std::move(condition),
                                   std::move(step), std::move(result));
 }
@@ -204,7 +204,7 @@ absl::optional<Expr> ExpandMap2Macro(MacroExprFactory& factory, Expr& target,
       CelOperator::ADD, factory.NewAccuIdent(),
       factory.NewList(factory.NewListElement(std::move(args[1]))));
   return factory.NewComprehension(args[0].ident_expr().name(),
-                                  std::move(target), kAccumulatorVariableName,
+                                  std::move(target), factory.AccuVarName(),
                                   std::move(init), std::move(condition),
                                   std::move(step), factory.NewAccuIdent());
 }
@@ -237,7 +237,7 @@ absl::optional<Expr> ExpandMap3Macro(MacroExprFactory& factory, Expr& target,
   step = factory.NewCall(CelOperator::CONDITIONAL, std::move(args[1]),
                          std::move(step), factory.NewAccuIdent());
   return factory.NewComprehension(args[0].ident_expr().name(),
-                                  std::move(target), kAccumulatorVariableName,
+                                  std::move(target), factory.AccuVarName(),
                                   std::move(init), std::move(condition),
                                   std::move(step), factory.NewAccuIdent());
 }
@@ -272,7 +272,7 @@ absl::optional<Expr> ExpandFilterMacro(MacroExprFactory& factory, Expr& target,
   step = factory.NewCall(CelOperator::CONDITIONAL, std::move(args[1]),
                          std::move(step), factory.NewAccuIdent());
   return factory.NewComprehension(std::move(name), std::move(target),
-                                  kAccumulatorVariableName, std::move(init),
+                                  factory.AccuVarName(), std::move(init),
                                   std::move(condition), std::move(step),
                                   factory.NewAccuIdent());
 }
diff --git a/parser/macro_expr_factory.h b/parser/macro_expr_factory.h
index 291bccdb0..83e322d4e 100644
--- a/parser/macro_expr_factory.h
+++ b/parser/macro_expr_factory.h
@@ -107,6 +107,8 @@ class MacroExprFactory : protected ExprFactory {
     return NewIdent(NextId(), std::move(name));
   }
 
+  absl::string_view AccuVarName() { return ExprFactory::AccuVarName(); }
+
   ABSL_MUST_USE_RESULT Expr NewAccuIdent() { return NewAccuIdent(NextId()); }
 
   template <typename Operand, typename Field,
@@ -282,6 +284,7 @@ class MacroExprFactory : protected ExprFactory {
       const Expr& expr, absl::string_view message) = 0;
 
  protected:
+  using ExprFactory::AccuVarName;
   using ExprFactory::NewAccuIdent;
   using ExprFactory::NewBoolConst;
   using ExprFactory::NewBytesConst;
@@ -316,7 +319,8 @@ class MacroExprFactory : protected ExprFactory {
   friend class ParserMacroExprFactory;
   friend class TestMacroExprFactory;
 
-  MacroExprFactory() : ExprFactory() {}
+  explicit MacroExprFactory(absl::string_view accu_var)
+      : ExprFactory(accu_var) {}
 };
 
 }  // namespace cel
diff --git a/parser/macro_expr_factory_test.cc b/parser/macro_expr_factory_test.cc
index 54742af91..04705eec6 100644
--- a/parser/macro_expr_factory_test.cc
+++ b/parser/macro_expr_factory_test.cc
@@ -27,7 +27,7 @@ namespace cel {
 
 class TestMacroExprFactory final : public MacroExprFactory {
  public:
-  TestMacroExprFactory() : MacroExprFactory() {}
+  TestMacroExprFactory() : MacroExprFactory(kAccumulatorVariableName) {}
 
   ExprId id() const { return id_; }
 
diff --git a/parser/options.h b/parser/options.h
index c879d8e37..50f02a4bb 100644
--- a/parser/options.h
+++ b/parser/options.h
@@ -50,6 +50,9 @@ struct ParserOptions final {
 
   // Disable standard macros (has, all, exists, exists_one, filter, map).
   bool disable_standard_macros = false;
+
+  // Enable hidden accumulator variable '@result' for builtin comprehensions.
+  bool enable_hidden_accumulator_var = false;
 };
 
 }  // namespace cel
diff --git a/parser/parser.cc b/parser/parser.cc
index b051b1ca0..50d72b7e5 100644
--- a/parser/parser.cc
+++ b/parser/parser.cc
@@ -55,6 +55,7 @@
 #include "base/ast_internal/expr.h"
 #include "common/ast.h"
 #include "common/constant.h"
+#include "common/expr.h"
 #include "common/expr_factory.h"
 #include "common/operators.h"
 #include "common/source.h"
@@ -84,6 +85,8 @@ namespace cel {
 
 namespace {
 
+constexpr const char kHiddenAccumulatorVariableName[] = "@result";
+
 std::any ExprPtrToAny(std::unique_ptr<Expr>&& expr) {
   return std::make_any<Expr*>(expr.release());
 }
@@ -158,8 +161,9 @@ SourceRange SourceRangeFromParserRuleContext(
 
 class ParserMacroExprFactory final : public MacroExprFactory {
  public:
-  explicit ParserMacroExprFactory(const cel::Source& source)
-      : MacroExprFactory(), source_(source) {}
+  explicit ParserMacroExprFactory(const cel::Source& source,
+                                  absl::string_view accu_var)
+      : MacroExprFactory(accu_var), source_(source) {}
 
   void BeginMacro(SourceRange macro_position) {
     macro_position_ = macro_position;
@@ -601,6 +605,7 @@ class ParserVisitor final : public CelBaseVisitor,
                             public antlr4::BaseErrorListener {
  public:
   ParserVisitor(const cel::Source& source, int max_recursion_depth,
+                absl::string_view accu_var,
                 const cel::MacroRegistry& macro_registry,
                 bool add_macro_calls = false,
                 bool enable_optional_syntax = false);
@@ -704,11 +709,12 @@ class ParserVisitor final : public CelBaseVisitor,
 
 ParserVisitor::ParserVisitor(const cel::Source& source,
                              const int max_recursion_depth,
+                             absl::string_view accu_var,
                              const cel::MacroRegistry& macro_registry,
                              const bool add_macro_calls,
                              bool enable_optional_syntax)
     : source_(source),
-      factory_(source_),
+      factory_(source_, accu_var),
       macro_registry_(macro_registry),
       recursion_depth_(0),
       max_recursion_depth_(max_recursion_depth),
@@ -1617,8 +1623,12 @@ absl::StatusOr<ParseResult> ParseImpl(const cel::Source& source,
     CommonTokenStream tokens(&lexer);
     CelParser parser(&tokens);
     ExprRecursionListener listener(options.max_recursion_depth);
-    ParserVisitor visitor(source, options.max_recursion_depth, registry,
-                          options.add_macro_calls,
+    absl::string_view accu_var = cel::kAccumulatorVariableName;
+    if (options.enable_hidden_accumulator_var) {
+      accu_var = cel::kHiddenAccumulatorVariableName;
+    }
+    ParserVisitor visitor(source, options.max_recursion_depth, accu_var,
+                          registry, options.add_macro_calls,
                           options.enable_optional_syntax);
 
     lexer.removeErrorListeners();
diff --git a/parser/parser_test.cc b/parser/parser_test.cc
index af31800bf..1bf586bc8 100644
--- a/parser/parser_test.cc
+++ b/parser/parser_test.cc
@@ -1540,6 +1540,269 @@ TEST(ExpressionTest, RecursionDepthIgnoresParentheses) {
   EXPECT_THAT(result, IsOk());
 }
 
+const std::vector<TestInfo>& UpdatedAccuVarTestCases() {
+  static const std::vector<TestInfo>* kInstance = new std::vector<TestInfo>{
+      {"[].exists(x, x > 0)",
+       "__comprehension__(\n"
+       "  // Variable\n"
+       "  x,\n"
+       "  // Target\n"
+       "  []^#1:Expr.CreateList#,\n"
+       "  // Accumulator\n"
+       "  @result,\n"
+       "  // Init\n"
+       "  false^#7:bool#,\n"
+       "  // LoopCondition\n"
+       "  @not_strictly_false(\n"
+       "    !_(\n"
+       "      @result^#8:Expr.Ident#\n"
+       "    )^#9:Expr.Call#\n"
+       "  )^#10:Expr.Call#,\n"
+       "  // LoopStep\n"
+       "  _||_(\n"
+       "    @result^#11:Expr.Ident#,\n"
+       "    _>_(\n"
+       "      x^#4:Expr.Ident#,\n"
+       "      0^#6:int64#\n"
+       "    )^#5:Expr.Call#\n"
+       "  )^#12:Expr.Call#,\n"
+       "  // Result\n"
+       "  @result^#13:Expr.Ident#)^#14:Expr.Comprehension#"},
+      {"[].exists_one(x, x > 0)",
+       "__comprehension__(\n"
+       "  // Variable\n"
+       "  x,\n"
+       "  // Target\n"
+       "  []^#1:Expr.CreateList#,\n"
+       "  // Accumulator\n"
+       "  @result,\n"
+       "  // Init\n"
+       "  0^#7:int64#,\n"
+       "  // LoopCondition\n"
+       "  true^#8:bool#,\n"
+       "  // LoopStep\n"
+       "  _?_:_(\n"
+       "    _>_(\n"
+       "      x^#4:Expr.Ident#,\n"
+       "      0^#6:int64#\n"
+       "    )^#5:Expr.Call#,\n"
+       "    _+_(\n"
+       "      @result^#9:Expr.Ident#,\n"
+       "      1^#10:int64#\n"
+       "    )^#11:Expr.Call#,\n"
+       "    @result^#12:Expr.Ident#\n"
+       "  )^#13:Expr.Call#,\n"
+       "  // Result\n"
+       "  _==_(\n"
+       "    @result^#14:Expr.Ident#,\n"
+       "    1^#15:int64#\n"
+       "  )^#16:Expr.Call#)^#17:Expr.Comprehension#"},
+      {"[].all(x, x > 0)",
+       "__comprehension__(\n"
+       "  // Variable\n"
+       "  x,\n"
+       "  // Target\n"
+       "  []^#1:Expr.CreateList#,\n"
+       "  // Accumulator\n"
+       "  @result,\n"
+       "  // Init\n"
+       "  true^#7:bool#,\n"
+       "  // LoopCondition\n"
+       "  @not_strictly_false(\n"
+       "    @result^#8:Expr.Ident#\n"
+       "  )^#9:Expr.Call#,\n"
+       "  // LoopStep\n"
+       "  _&&_(\n"
+       "    @result^#10:Expr.Ident#,\n"
+       "    _>_(\n"
+       "      x^#4:Expr.Ident#,\n"
+       "      0^#6:int64#\n"
+       "    )^#5:Expr.Call#\n"
+       "  )^#11:Expr.Call#,\n"
+       "  // Result\n"
+       "  @result^#12:Expr.Ident#)^#13:Expr.Comprehension#"},
+      {"[].map(x, x + 1)",
+       "__comprehension__(\n"
+       "  // Variable\n"
+       "  x,\n"
+       "  // Target\n"
+       "  []^#1:Expr.CreateList#,\n"
+       "  // Accumulator\n"
+       "  @result,\n"
+       "  // Init\n"
+       "  []^#7:Expr.CreateList#,\n"
+       "  // LoopCondition\n"
+       "  true^#8:bool#,\n"
+       "  // LoopStep\n"
+       "  _+_(\n"
+       "    @result^#9:Expr.Ident#,\n"
+       "    [\n"
+       "      _+_(\n"
+       "        x^#4:Expr.Ident#,\n"
+       "        1^#6:int64#\n"
+       "      )^#5:Expr.Call#\n"
+       "    ]^#10:Expr.CreateList#\n"
+       "  )^#11:Expr.Call#,\n"
+       "  // Result\n"
+       "  @result^#12:Expr.Ident#)^#13:Expr.Comprehension#"},
+      {"[].map(x, x > 0, x + 1)",
+       "__comprehension__(\n"
+       "  // Variable\n"
+       "  x,\n"
+       "  // Target\n"
+       "  []^#1:Expr.CreateList#,\n"
+       "  // Accumulator\n"
+       "  @result,\n"
+       "  // Init\n"
+       "  []^#10:Expr.CreateList#,\n"
+       "  // LoopCondition\n"
+       "  true^#11:bool#,\n"
+       "  // LoopStep\n"
+       "  _?_:_(\n"
+       "    _>_(\n"
+       "      x^#4:Expr.Ident#,\n"
+       "      0^#6:int64#\n"
+       "    )^#5:Expr.Call#,\n"
+       "    _+_(\n"
+       "      @result^#12:Expr.Ident#,\n"
+       "      [\n"
+       "        _+_(\n"
+       "          x^#7:Expr.Ident#,\n"
+       "          1^#9:int64#\n"
+       "        )^#8:Expr.Call#\n"
+       "      ]^#13:Expr.CreateList#\n"
+       "    )^#14:Expr.Call#,\n"
+       "    @result^#15:Expr.Ident#\n"
+       "  )^#16:Expr.Call#,\n"
+       "  // Result\n"
+       "  @result^#17:Expr.Ident#)^#18:Expr.Comprehension#"},
+      {"[].filter(x, x > 0)",
+       "__comprehension__(\n"
+       "  // Variable\n"
+       "  x,\n"
+       "  // Target\n"
+       "  []^#1:Expr.CreateList#,\n"
+       "  // Accumulator\n"
+       "  @result,\n"
+       "  // Init\n"
+       "  []^#7:Expr.CreateList#,\n"
+       "  // LoopCondition\n"
+       "  true^#8:bool#,\n"
+       "  // LoopStep\n"
+       "  _?_:_(\n"
+       "    _>_(\n"
+       "      x^#4:Expr.Ident#,\n"
+       "      0^#6:int64#\n"
+       "    )^#5:Expr.Call#,\n"
+       "    _+_(\n"
+       "      @result^#9:Expr.Ident#,\n"
+       "      [\n"
+       "        x^#3:Expr.Ident#\n"
+       "      ]^#10:Expr.CreateList#\n"
+       "    )^#11:Expr.Call#,\n"
+       "    @result^#12:Expr.Ident#\n"
+       "  )^#13:Expr.Call#,\n"
+       "  // Result\n"
+       "  @result^#14:Expr.Ident#)^#15:Expr.Comprehension#"},
+      // Maintain restriction on '__result__' variable name until the default is
+      // changed everywhere.
+      {
+          "[].map(__result__, true)",
+          /*.P=*/"",
+          /*.E=*/
+          "ERROR: <input>:1:20: map() variable name cannot be __result__\n"
+          " | [].map(__result__, true)\n"
+          " | ...................^",
+      },
+      {
+          "[].map(__result__, true, false)",
+          /*.P=*/"",
+          /*.E=*/
+          "ERROR: <input>:1:20: map() variable name cannot be __result__\n"
+          " | [].map(__result__, true, false)\n"
+          " | ...................^",
+      },
+      {
+          "[].filter(__result__, true)",
+          /*.P=*/"",
+          /*.E=*/
+          "ERROR: <input>:1:23: filter() variable name cannot be __result__\n"
+          " | [].filter(__result__, true)\n"
+          " | ......................^",
+      },
+      {
+          "[].exists(__result__, true)",
+          /*.P=*/"",
+          /*.E=*/
+          "ERROR: <input>:1:23: exists() variable name cannot be __result__\n"
+          " | [].exists(__result__, true)\n"
+          " | ......................^",
+      },
+      {
+          "[].all(__result__, true)",
+          /*.P=*/"",
+          /*.E=*/
+          "ERROR: <input>:1:20: all() variable name cannot be __result__\n"
+          " | [].all(__result__, true)\n"
+          " | ...................^",
+      },
+      {
+          "[].exists_one(__result__, true)",
+          /*.P=*/"",
+          /*.E=*/
+          "ERROR: <input>:1:27: exists_one() variable name cannot be "
+          "__result__\n"
+          " | [].exists_one(__result__, true)\n"
+          " | ..........................^",
+      }};
+  return *kInstance;
+}
+
+class UpdatedAccuVarTest : public testing::TestWithParam<TestInfo> {};
+
+TEST_P(UpdatedAccuVarTest, Parse) {
+  const TestInfo& test_info = GetParam();
+  ParserOptions options;
+  options.enable_hidden_accumulator_var = true;
+  if (!test_info.M.empty()) {
+    options.add_macro_calls = true;
+  }
+
+  auto result =
+      EnrichedParse(test_info.I, Macro::AllMacros(), "<input>", options);
+  if (test_info.E.empty()) {
+    EXPECT_THAT(result, IsOk());
+  } else {
+    EXPECT_THAT(result, Not(IsOk()));
+    EXPECT_EQ(test_info.E, result.status().message());
+  }
+
+  if (!test_info.P.empty()) {
+    KindAndIdAdorner kind_and_id_adorner;
+    ExprPrinter w(kind_and_id_adorner);
+    std::string adorned_string = w.PrintProto(result->parsed_expr().expr());
+    EXPECT_EQ(test_info.P, adorned_string) << result->parsed_expr();
+  }
+
+  if (!test_info.L.empty()) {
+    LocationAdorner location_adorner(result->parsed_expr().source_info());
+    ExprPrinter w(location_adorner);
+    std::string adorned_string = w.PrintProto(result->parsed_expr().expr());
+    EXPECT_EQ(test_info.L, adorned_string) << result->parsed_expr();
+  }
+
+  if (!test_info.R.empty()) {
+    EXPECT_EQ(test_info.R, ConvertEnrichedSourceInfoToString(
+                               result->enriched_source_info()));
+  }
+
+  if (!test_info.M.empty()) {
+    EXPECT_EQ(test_info.M, ConvertMacroCallsToString(
+                               result.value().parsed_expr().source_info()))
+        << result->parsed_expr();
+  }
+}
+
 TEST(NewParserBuilderTest, Defaults) {
   auto builder = cel::NewParserBuilder();
   ASSERT_OK_AND_ASSIGN(auto parser, std::move(*builder).Build());
@@ -1601,6 +1864,10 @@ std::string TestName(const testing::TestParamInfo<TestInfo>& test_info) {
 INSTANTIATE_TEST_SUITE_P(CelParserTest, ExpressionTest,
                          testing::ValuesIn(test_cases), TestName);
 
+INSTANTIATE_TEST_SUITE_P(UpdatedAccuVarTest, UpdatedAccuVarTest,
+                         testing::ValuesIn(UpdatedAccuVarTestCases()),
+                         TestName);
+
 void BM_Parse(benchmark::State& state) {
   std::vector<Macro> macros = Macro::AllMacros();
   for (auto s : state) {