diff --git a/runtime/function_adapter.h b/runtime/function_adapter.h
index e64edd232..641ad0609 100644
--- a/runtime/function_adapter.h
+++ b/runtime/function_adapter.h
@@ -18,20 +18,21 @@
 #ifndef THIRD_PARTY_CEL_CPP_RUNTIME_FUNCTION_ADAPTER_H_
 #define THIRD_PARTY_CEL_CPP_RUNTIME_FUNCTION_ADAPTER_H_
 
+#include <cstddef>
 #include <functional>
 #include <memory>
+#include <tuple>
+#include <utility>
 #include <vector>
 
 #include "absl/base/nullability.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/functional/bind_front.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "common/function_descriptor.h"
-#include "common/kind.h"
 #include "common/value.h"
 #include "internal/status_macros.h"
 #include "runtime/function.h"
@@ -94,79 +95,73 @@ struct AdaptedTypeTraits<const T&> {
   static T ToArg(AssignableType v) { return v; }
 };
 
-template <typename... Args>
-struct KindAdderImpl;
-
-template <typename Arg, typename... Args>
-struct KindAdderImpl<Arg, Args...> {
-  static void AddTo(std::vector<cel::Kind>& args) {
-    args.push_back(AdaptedKind<Arg>());
-    KindAdderImpl<Args...>::AddTo(args);
+template <size_t I, typename... Args>
+struct AdaptHelperImpl {
+  template <typename T>
+  static absl::Status Apply(absl::Span<const Value> input, T& output) {
+    static_assert(sizeof...(Args) > 0);
+    static_assert(std::tuple_size_v<T> == sizeof...(Args));
+    CEL_RETURN_IF_ERROR(HandleToAdaptedVisitor{input[I]}(&std::get<I>(output)));
+    if constexpr (I == sizeof...(Args) - 1) {
+      return absl::OkStatus();
+    } else {
+      CEL_RETURN_IF_ERROR(
+          (AdaptHelperImpl<I + 1, Args...>::template Apply<T>(input, output)));
+    }
+    return absl::OkStatus();
   }
 };
 
-template <>
-struct KindAdderImpl<> {
-  static void AddTo(std::vector<cel::Kind>& args) {}
-};
-
 template <typename... Args>
-struct KindAdder {
-  static std::vector<cel::Kind> Kinds() {
-    std::vector<cel::Kind> args;
-    KindAdderImpl<Args...>::AddTo(args);
-    return args;
+struct AdaptHelper {
+  template <typename T>
+  static absl::Status Apply(absl::Span<const Value> input, T& output) {
+    return AdaptHelperImpl<0, Args...>::template Apply<T>(input, output);
   }
 };
 
-template <typename T>
-struct ApplyReturnType {
-  using type = absl::StatusOr<T>;
-};
-
-template <typename T>
-struct ApplyReturnType<absl::StatusOr<T>> {
-  using type = absl::StatusOr<T>;
-};
-
-template <int N, typename Arg, typename... Args>
-struct IndexerImpl {
-  using type = typename IndexerImpl<N - 1, Args...>::type;
-};
-
-template <typename Arg, typename... Args>
-struct IndexerImpl<0, Arg, Args...> {
-  using type = Arg;
-};
+template <typename... Args>
+struct ToArgsImpl {
+  template <int I, typename T>
+  struct El {
+    using type = T;
+    constexpr static size_t index = I;
+  };
 
-template <int N, typename... Args>
-struct Indexer {
-  static_assert(N < sizeof...(Args) && N >= 0);
-  using type = typename IndexerImpl<N, Args...>::type;
-};
+  template <typename... Es>
+  struct ZipHolder {
+    template <typename ResultType, typename TupleType, typename Op>
+    static ResultType ToArgs(
+        Op&& op, const TupleType& argbuffer,
+        const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+        google::protobuf::MessageFactory* absl_nonnull message_factory,
+        google::protobuf::Arena* absl_nonnull arena) {
+      return std::forward<Op>(op)(
+          runtime_internal::AdaptedTypeTraits<typename Es::type>::ToArg(
+              std::get<Es::index>(argbuffer))...,
+          descriptor_pool, message_factory, arena);
+    }
+  };
 
-template <int N, typename... Args>
-struct ApplyHelper {
-  template <typename T, typename Op>
-  static typename ApplyReturnType<T>::type Apply(
-      Op&& op, absl::Span<const Value> input) {
-    constexpr int idx = sizeof...(Args) - N;
-    using Arg = typename Indexer<idx, Args...>::type;
-    using ArgTraits = AdaptedTypeTraits<Arg>;
-    typename ArgTraits::AssignableType arg_i;
-    CEL_RETURN_IF_ERROR(HandleToAdaptedVisitor{input[idx]}(&arg_i));
-
-    return ApplyHelper<N - 1, Args...>::template Apply<T>(
-        absl::bind_front(std::forward<Op>(op), ArgTraits::ToArg(arg_i)), input);
+  template <size_t... Is>
+  static ZipHolder<El<Is, Args>...> MakeZip(const std::index_sequence<Is...>&) {
+    return ZipHolder<El<Is, Args>...>{};
   }
 };
 
 template <typename... Args>
-struct ApplyHelper<0, Args...> {
-  template <typename T, typename Op>
-  static typename ApplyReturnType<T>::type Apply(
-      Op&& op, absl::Span<const Value> input) {
-    return op();
+struct ToArgsHelper {
+  template <typename ResultType, typename TupleType, typename Op>
+  static ResultType Apply(
+      Op&& op, const TupleType& argbuffer,
+      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+      google::protobuf::MessageFactory* absl_nonnull message_factory,
+      google::protobuf::Arena* absl_nonnull arena) {
+    using Impl = ToArgsImpl<Args...>;
+    using Zip = decltype(Impl::MakeZip(std::index_sequence_for<Args...>{}));
+    return Zip::template ToArgs<ResultType>(std::forward<Op>(op), argbuffer,
+                                            descriptor_pool, message_factory,
+                                            arena);
   }
 };
 
@@ -629,6 +624,98 @@ class QuaternaryFunctionAdapter
   };
 };
 
+// Primary template for n-ary adapter.
+template <typename T, typename... Args>
+class NaryFunctionAdapter;
+
+template <typename T>
+class NaryFunctionAdapter<T> : public NullaryFunctionAdapter<T> {};
+
+template <typename T, typename U>
+class NaryFunctionAdapter<T, U> : public UnaryFunctionAdapter<T, U> {};
+
+template <typename T, typename U, typename V>
+class NaryFunctionAdapter<T, U, V> : public BinaryFunctionAdapter<T, U, V> {};
+
+template <typename T, typename U, typename V, typename W>
+class NaryFunctionAdapter<T, U, V, W>
+    : public TernaryFunctionAdapter<T, U, V, W> {};
+
+template <typename T, typename U, typename V, typename W, typename X>
+class NaryFunctionAdapter<T, U, V, W, X>
+    : public QuaternaryFunctionAdapter<T, U, V, W, X> {};
+
+// N-ary function adapter.
+//
+// Prefer using one of the specific count adapters above for readability and
+// better error messages.
+template <typename T, typename... Args>
+class NaryFunctionAdapter
+    : public RegisterHelper<NaryFunctionAdapter<T, Args...>> {
+ public:
+  using FunctionType = absl::AnyInvocable<T(
+      Args..., const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+      google::protobuf::MessageFactory* absl_nonnull message_factory,
+      google::protobuf::Arena* absl_nonnull arena) const>;
+
+  static FunctionDescriptor CreateDescriptor(absl::string_view name,
+                                             bool receiver_style,
+                                             bool is_strict = true) {
+    return FunctionDescriptor(name, receiver_style,
+                              {runtime_internal::AdaptedKind<Args>()...},
+                              is_strict);
+  }
+
+  static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
+    return std::make_unique<NaryFunctionImpl>(std::move(fn));
+  }
+
+  static std::unique_ptr<cel::Function> WrapFunction(
+      absl::AnyInvocable<T(Args...) const> function) {
+    return WrapFunction(
+        [function = std::move(function)](
+            Args... args, const google::protobuf::DescriptorPool* absl_nonnull,
+            google::protobuf::MessageFactory* absl_nonnull,
+            google::protobuf::Arena* absl_nonnull) -> T { return function(args...); });
+  }
+
+ private:
+  class NaryFunctionImpl : public cel::Function {
+   private:
+    using ArgBuffer = std::tuple<
+        typename runtime_internal::AdaptedTypeTraits<Args>::AssignableType...>;
+
+   public:
+    explicit NaryFunctionImpl(FunctionType fn) : fn_(std::move(fn)) {}
+    absl::StatusOr<Value> Invoke(
+        absl::Span<const Value> args,
+        const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+        google::protobuf::MessageFactory* absl_nonnull message_factory,
+        google::protobuf::Arena* absl_nonnull arena) const override {
+      if (args.size() != sizeof...(Args)) {
+        return absl::InvalidArgumentError(
+            absl::StrCat("unexpected number of arguments for ", sizeof...(Args),
+                         "-ary function"));
+      }
+      ArgBuffer arg_buffer;
+      CEL_RETURN_IF_ERROR(
+          runtime_internal::AdaptHelper<Args...>::Apply(args, arg_buffer));
+      if constexpr (std::is_same_v<T, Value> ||
+                    std::is_same_v<T, absl::StatusOr<Value>>) {
+        return runtime_internal::ToArgsHelper<Args...>::template Apply<T>(
+            fn_, arg_buffer, descriptor_pool, message_factory, arena);
+      } else {
+        T result = runtime_internal::ToArgsHelper<Args...>::template Apply<T>(
+            fn_, arg_buffer, descriptor_pool, message_factory, arena);
+        return runtime_internal::AdaptedToHandleVisitor{}(std::move(result));
+      }
+    }
+
+   private:
+    FunctionType fn_;
+  };
+};
+
 }  // namespace cel
 
 #endif  // THIRD_PARTY_CEL_CPP_RUNTIME_FUNCTION_ADAPTER_H_
diff --git a/runtime/function_adapter_test.cc b/runtime/function_adapter_test.cc
index 820a08600..aad5e4086 100644
--- a/runtime/function_adapter_test.cc
+++ b/runtime/function_adapter_test.cc
@@ -686,7 +686,7 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterCreateDescriptorNonStrict) {
   EXPECT_THAT(desc.types(), ElementsAre(Kind::kAny, Kind::kAny));
 }
 
-TEST_F(FunctionAdapterTest, VariadicFunctionAdapterCreateDescriptor0Args) {
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterCreateDescriptor0Args) {
   FunctionDescriptor desc =
       NullaryFunctionAdapter<absl::StatusOr<Value>>::CreateDescriptor(
           "ZeroArgs", false);
@@ -697,7 +697,7 @@ TEST_F(FunctionAdapterTest, VariadicFunctionAdapterCreateDescriptor0Args) {
   EXPECT_THAT(desc.types(), IsEmpty());
 }
 
-TEST_F(FunctionAdapterTest, VariadicFunctionAdapterWrapFunction0Args) {
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction0Args) {
   std::unique_ptr<Function> fn =
       NullaryFunctionAdapter<absl::StatusOr<Value>>::WrapFunction(
           []() { return StringValue("abc"); });
@@ -708,7 +708,7 @@ TEST_F(FunctionAdapterTest, VariadicFunctionAdapterWrapFunction0Args) {
   EXPECT_EQ(result.GetString().ToString(), "abc");
 }
 
-TEST_F(FunctionAdapterTest, VariadicFunctionAdapterCreateDescriptor3Args) {
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterCreateDescriptor3Args) {
   FunctionDescriptor desc = TernaryFunctionAdapter<
       absl::StatusOr<Value>, int64_t, bool,
       const StringValue&>::CreateDescriptor("MyFormatter", false);
@@ -720,8 +720,8 @@ TEST_F(FunctionAdapterTest, VariadicFunctionAdapterCreateDescriptor3Args) {
               ElementsAre(Kind::kInt64, Kind::kBool, Kind::kString));
 }
 
-TEST_F(FunctionAdapterTest, VariadicFunctionAdapterWrapFunction3Args) {
-  std::unique_ptr<Function> fn = TernaryFunctionAdapter<
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction3Args) {
+  std::unique_ptr<Function> fn = NaryFunctionAdapter<
       absl::StatusOr<Value>, int64_t, bool,
       const StringValue&>::WrapFunction([](int64_t int_val, bool bool_val,
                                            const StringValue& string_val)
@@ -738,9 +738,8 @@ TEST_F(FunctionAdapterTest, VariadicFunctionAdapterWrapFunction3Args) {
   EXPECT_EQ(result.GetString().ToString(), "42_false_abcd");
 }
 
-TEST_F(FunctionAdapterTest,
-       VariadicFunctionAdapterWrapFunction3ArgsBadArgType) {
-  std::unique_ptr<Function> fn = TernaryFunctionAdapter<
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction3ArgsBadArgType) {
+  std::unique_ptr<Function> fn = NaryFunctionAdapter<
       absl::StatusOr<Value>, int64_t, bool,
       const StringValue&>::WrapFunction([](int64_t int_val, bool bool_val,
                                            const StringValue& string_val)
@@ -756,9 +755,8 @@ TEST_F(FunctionAdapterTest,
                        HasSubstr("expected string value")));
 }
 
-TEST_F(FunctionAdapterTest,
-       VariadicFunctionAdapterWrapFunction3ArgsBadArgCount) {
-  std::unique_ptr<Function> fn = TernaryFunctionAdapter<
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction3ArgsBadArgCount) {
+  std::unique_ptr<Function> fn = NaryFunctionAdapter<
       absl::StatusOr<Value>, int64_t, bool,
       const StringValue&>::WrapFunction([](int64_t int_val, bool bool_val,
                                            const StringValue& string_val)
@@ -773,5 +771,82 @@ TEST_F(FunctionAdapterTest,
                        HasSubstr("unexpected number of arguments")));
 }
 
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterCreateDescriptor5Args) {
+  FunctionDescriptor desc =
+      NaryFunctionAdapter<absl::StatusOr<Value>, int64_t, bool,
+                          const StringValue&, int64_t,
+                          int64_t>::CreateDescriptor("MyFormatter", false);
+
+  EXPECT_EQ(desc.name(), "MyFormatter");
+  EXPECT_TRUE(desc.is_strict());
+  EXPECT_FALSE(desc.receiver_style());
+  EXPECT_THAT(desc.types(),
+              ElementsAre(Kind::kInt64, Kind::kBool, Kind::kString,
+                          Kind::kInt64, Kind::kInt64));
+}
+
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5Args) {
+  std::unique_ptr<Function> fn = NaryFunctionAdapter<
+      absl::StatusOr<Value>, int64_t, bool, const StringValue&, int64_t,
+      int64_t>::WrapFunction([](int64_t int_val, bool bool_val,
+                                const StringValue& string_val,
+                                int64_t extra_arg,
+                                int64_t extra_arg2) -> absl::StatusOr<Value> {
+    return StringValue(absl::StrCat(int_val, "_", (bool_val ? "true" : "false"),
+                                    "_", string_val.ToString(), "_", extra_arg,
+                                    "_", extra_arg2));
+  });
+
+  std::vector<Value> args{IntValue(42), BoolValue(false)};
+  args.emplace_back() = StringValue("abcd");
+  args.push_back(IntValue(123));
+  args.push_back(IntValue(456));
+  ASSERT_OK_AND_ASSIGN(auto result, fn->Invoke(args, descriptor_pool(),
+                                               message_factory(), arena()));
+  ASSERT_TRUE(result->Is<StringValue>());
+  EXPECT_EQ(result.GetString().ToString(), "42_false_abcd_123_456");
+}
+
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5ArgsBadArgType) {
+  std::unique_ptr<Function> fn = NaryFunctionAdapter<
+      absl::StatusOr<Value>, int64_t, bool, const StringValue&, int64_t,
+      int64_t>::WrapFunction([](int64_t int_val, bool bool_val,
+                                const StringValue& string_val,
+                                int64_t extra_arg,
+                                int64_t extra_arg2) -> absl::StatusOr<Value> {
+    static_cast<void>(extra_arg);
+    static_cast<void>(extra_arg2);
+    return StringValue(absl::StrCat(int_val, "_", (bool_val ? "true" : "false"),
+                                    "_", string_val.ToString()));
+  });
+
+  std::vector<Value> args{IntValue(42), BoolValue(false)};
+  args.emplace_back() = TimestampValue(absl::UnixEpoch());
+  args.push_back(IntValue(123));
+  args.push_back(IntValue(456));
+  EXPECT_THAT(fn->Invoke(args, descriptor_pool(), message_factory(), arena()),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("expected string value")));
+}
+
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5ArgsBadArgCount) {
+  std::unique_ptr<Function> fn = NaryFunctionAdapter<
+      absl::StatusOr<Value>, int64_t, bool, const StringValue&, int64_t,
+      int64_t>::WrapFunction([](int64_t int_val, bool bool_val,
+                                const StringValue& string_val,
+                                int64_t extra_arg,
+                                int64_t extra_arg2) -> absl::StatusOr<Value> {
+    static_cast<void>(extra_arg);
+    static_cast<void>(extra_arg2);
+    return StringValue(absl::StrCat(int_val, "_", (bool_val ? "true" : "false"),
+                                    "_", string_val.ToString()));
+  });
+
+  std::vector<Value> args{IntValue(42), BoolValue(false)};
+  EXPECT_THAT(fn->Invoke(args, descriptor_pool(), message_factory(), arena()),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("unexpected number of arguments")));
+}
+
 }  // namespace
 }  // namespace cel