diff --git a/DifferentiationInterface/Project.toml b/DifferentiationInterface/Project.toml
index cd48a328b..39e53ba6e 100644
--- a/DifferentiationInterface/Project.toml
+++ b/DifferentiationInterface/Project.toml
@@ -1,7 +1,7 @@
 name = "DifferentiationInterface"
 uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"
 authors = ["Guillaume Dalle", "Adrian Hill"]
-version = "0.6.45"
+version = "0.6.46"
 
 [deps]
 ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/DifferentiationInterfaceForwardDiffExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/DifferentiationInterfaceForwardDiffExt.jl
index 47165a5d7..b978c065a 100644
--- a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/DifferentiationInterfaceForwardDiffExt.jl
+++ b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/DifferentiationInterfaceForwardDiffExt.jl
@@ -24,6 +24,7 @@ using ForwardDiff:
     jacobian,
     jacobian!,
     partials,
+    pickchunksize,
     value
 
 DI.check_available(::AutoForwardDiff) = true
@@ -31,7 +32,7 @@ DI.check_available(::AutoForwardDiff) = true
 include("utils.jl")
 include("onearg.jl")
 include("twoarg.jl")
-include("secondorder.jl")
+# include("secondorder.jl")
 include("differentiate_with.jl")
 include("misc.jl")
 
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/onearg.jl
index 292b9b787..b405cbb8d 100644
--- a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/onearg.jl
+++ b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/onearg.jl
@@ -7,7 +7,7 @@ function DI.value_and_pushforward(
 ) where {F,B,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, tx)
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate(eltype(xdual), contexts)
     ydual = f(xdual, contexts_dual...)
     y = myvalue(T, ydual)
     ty = mypartials(T, Val(B), ydual)
@@ -24,7 +24,7 @@ function DI.value_and_pushforward!(
 ) where {F,B,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, tx)
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate(eltype(xdual), contexts)
     ydual = f(xdual, contexts_dual...)
     y = myvalue(T, ydual)
     mypartials!(T, ty, ydual)
@@ -36,7 +36,7 @@ function DI.pushforward(
 ) where {F,B,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, tx)
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate(eltype(xdual), contexts)
     ydual = f(xdual, contexts_dual...)
     ty = mypartials(T, Val(B), ydual)
     return ty
@@ -52,7 +52,7 @@ function DI.pushforward!(
 ) where {F,B,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, tx)
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate(eltype(xdual), contexts)
     ydual = f(xdual, contexts_dual...)
     mypartials!(T, ty, ydual)
     return ty
@@ -60,20 +60,24 @@ end
 
 ### Prepared
 
-struct ForwardDiffOneArgPushforwardPrep{T,X} <: DI.PushforwardPrep
+struct ForwardDiffOneArgPushforwardPrep{T,X,CD} <: DI.PushforwardPrep
     xdual_tmp::X
+    contexts_dual::CD
 end
 
 function DI.prepare_pushforward(
-    f::F, backend::AutoForwardDiff, x, tx::NTuple, contexts::Vararg{DI.Context,C}
-) where {F,C}
+    f::F, backend::AutoForwardDiff, x, tx::NTuple{B}, contexts::Vararg{DI.Context,C}
+) where {F,B,C}
     T = tag_type(f, backend, x)
     if DI.ismutable_array(x)
         xdual_tmp = make_dual_similar(T, x, tx)
     else
         xdual_tmp = nothing
     end
-    return ForwardDiffOneArgPushforwardPrep{T,typeof(xdual_tmp)}(xdual_tmp)
+    contexts_dual = translate_toprep(Dual{T,eltype(x),B}, contexts)
+    return ForwardDiffOneArgPushforwardPrep{T,typeof(xdual_tmp),typeof(contexts_dual)}(
+        xdual_tmp, contexts_dual
+    )
 end
 
 function compute_ydual_onearg(
@@ -84,7 +88,7 @@ function compute_ydual_onearg(
     contexts::Vararg{DI.Context,C},
 ) where {F,T,B,C}
     xdual = make_dual(T, x, tx)
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
     ydual = f(xdual, contexts_dual...)
     return ydual
 end
@@ -102,7 +106,7 @@ function compute_ydual_onearg(
     else
         xdual_tmp = make_dual(T, x, tx)
     end
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
     ydual = f(xdual_tmp, contexts_dual...)
     return ydual
 end
@@ -169,8 +173,39 @@ struct ForwardDiffOneArgDerivativePrep{E} <: DI.DerivativePrep
     pushforward_prep::E
 end
 
+### Unprepared
+
+function DI.value_and_derivative(
+    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
+) where {F,C}
+    y, ty = DI.value_and_pushforward(f, backend, x, (one(x),), contexts...)
+    return y, only(ty)
+end
+
+function DI.value_and_derivative!(
+    f::F, der, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
+) where {F,C}
+    y, _ = DI.value_and_pushforward!(f, (der,), backend, x, (one(x),), contexts...)
+    return y, der
+end
+
+function DI.derivative(
+    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
+) where {F,C}
+    return only(DI.pushforward(f, backend, x, (one(x),), contexts...))
+end
+
+function DI.derivative!(
+    f::F, der, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
+) where {F,C}
+    DI.pushforward!(f, (der,), backend, x, (one(x),), contexts...)
+    return der
+end
+
+### Prepared
+
 function DI.prepare_derivative(
-    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.ConstantOrFunctionOrBackend,C}
+    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
 ) where {F,C}
     pushforward_prep = DI.prepare_pushforward(f, backend, x, (one(x),), contexts...)
     return ForwardDiffOneArgDerivativePrep(pushforward_prep)
@@ -181,7 +216,7 @@ function DI.value_and_derivative(
     prep::ForwardDiffOneArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     y, ty = DI.value_and_pushforward(
         f, prep.pushforward_prep, backend, x, (one(x),), contexts...
@@ -195,7 +230,7 @@ function DI.value_and_derivative!(
     prep::ForwardDiffOneArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     y, _ = DI.value_and_pushforward!(
         f, (der,), prep.pushforward_prep, backend, x, (one(x),), contexts...
@@ -208,7 +243,7 @@ function DI.derivative(
     prep::ForwardDiffOneArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     return only(
         DI.pushforward(f, prep.pushforward_prep, backend, x, (one(x),), contexts...)
@@ -221,7 +256,7 @@ function DI.derivative!(
     prep::ForwardDiffOneArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     DI.pushforward!(f, (der,), prep.pushforward_prep, backend, x, (one(x),), contexts...)
     return der
@@ -232,13 +267,13 @@ end
 ### Unprepared, only when chunk size and tag are not specified
 
 function DI.value_and_gradient!(
-    f::F,
-    grad,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, grad, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         result = DiffResult(zero(eltype(x)), (grad,))
         result = gradient!(result, fc, x)
@@ -252,12 +287,13 @@ function DI.value_and_gradient!(
 end
 
 function DI.value_and_gradient(
-    f::F,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         result = GradientResult(x)
         result = gradient!(result, fc, x)
@@ -269,13 +305,13 @@ function DI.value_and_gradient(
 end
 
 function DI.gradient!(
-    f::F,
-    grad,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, grad, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         return gradient!(grad, fc, x)
     else
@@ -285,12 +321,13 @@ function DI.gradient!(
 end
 
 function DI.gradient(
-    f::F,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         return gradient(fc, x)
     else
@@ -301,21 +338,19 @@ end
 
 ### Prepared
 
-struct ForwardDiffGradientPrep{C} <: DI.GradientPrep
+struct ForwardDiffGradientPrep{C,CD} <: DI.GradientPrep
     config::C
+    contexts_dual::CD
 end
 
 function DI.prepare_gradient(
-    f::F,
-    backend::AutoForwardDiff,
-    x::AbstractArray,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff, x::AbstractArray, contexts::Vararg{DI.Context,C}
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
     chunk = choose_chunk(backend, x)
     tag = get_tag(f, backend, x)
-    config = GradientConfig(fc, x, chunk, tag)
-    return ForwardDiffGradientPrep(config)
+    config = GradientConfig(nothing, x, chunk, tag)
+    contexts_dual = translate_toprep(dual_type(config), contexts)
+    return ForwardDiffGradientPrep(config, contexts_dual)
 end
 
 function DI.value_and_gradient!(
@@ -324,9 +359,10 @@ function DI.value_and_gradient!(
     prep::ForwardDiffGradientPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     result = DiffResult(zero(eltype(x)), (grad,))
     CHK = tag_type(backend) === Nothing
     if CHK
@@ -343,9 +379,10 @@ function DI.value_and_gradient(
     prep::ForwardDiffGradientPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     result = GradientResult(x)
     CHK = tag_type(backend) === Nothing
     if CHK
@@ -361,9 +398,10 @@ function DI.gradient!(
     prep::ForwardDiffGradientPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f, x)
@@ -376,9 +414,10 @@ function DI.gradient(
     prep::ForwardDiffGradientPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f, x)
@@ -391,13 +430,13 @@ end
 ### Unprepared, only when chunk size and tag are not specified
 
 function DI.value_and_jacobian!(
-    f::F,
-    jac,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, jac, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         y = fc(x)
         result = DiffResult(y, (jac,))
@@ -412,12 +451,13 @@ function DI.value_and_jacobian!(
 end
 
 function DI.value_and_jacobian(
-    f::F,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         return fc(x), jacobian(fc, x)
     else
@@ -427,13 +467,13 @@ function DI.value_and_jacobian(
 end
 
 function DI.jacobian!(
-    f::F,
-    jac,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, jac, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         return jacobian!(jac, fc, x)
     else
@@ -443,12 +483,13 @@ function DI.jacobian!(
 end
 
 function DI.jacobian(
-    f::F,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         return jacobian(fc, x)
     else
@@ -459,18 +500,19 @@ end
 
 ### Prepared
 
-struct ForwardDiffOneArgJacobianPrep{C} <: DI.JacobianPrep
+struct ForwardDiffOneArgJacobianPrep{C,CD} <: DI.JacobianPrep
     config::C
+    contexts_dual::CD
 end
 
 function DI.prepare_jacobian(
-    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.ConstantOrFunctionOrBackend,C}
+    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
     chunk = choose_chunk(backend, x)
     tag = get_tag(f, backend, x)
-    config = JacobianConfig(fc, x, chunk, tag)
-    return ForwardDiffOneArgJacobianPrep(config)
+    config = JacobianConfig(nothing, x, chunk, tag)
+    contexts_dual = translate_toprep(dual_type(config), contexts)
+    return ForwardDiffOneArgJacobianPrep(config, contexts_dual)
 end
 
 function DI.value_and_jacobian!(
@@ -479,9 +521,10 @@ function DI.value_and_jacobian!(
     prep::ForwardDiffOneArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     y = fc(x)
     result = DiffResult(y, (jac,))
     CHK = tag_type(backend) === Nothing
@@ -499,9 +542,10 @@ function DI.value_and_jacobian(
     prep::ForwardDiffOneArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f, x)
@@ -515,9 +559,10 @@ function DI.jacobian!(
     prep::ForwardDiffOneArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f, x)
@@ -530,9 +575,10 @@ function DI.jacobian(
     prep::ForwardDiffOneArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f, x)
@@ -543,7 +589,7 @@ end
 ## Second derivative
 
 function DI.prepare_second_derivative(
-    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.ConstantOrFunctionOrBackend,C}
+    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
 ) where {F,C}
     return DI.NoSecondDerivativePrep()
 end
@@ -553,12 +599,14 @@ function DI.second_derivative(
     ::DI.NoSecondDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, one(x))
     T2 = tag_type(f, backend, xdual)
-    ydual = f(make_dual(T2, xdual, one(xdual)), map(DI.unwrap, contexts)...)
+    xdual2 = make_dual(T2, xdual, one(xdual))
+    contexts_dual = translate(typeof(xdual2), contexts)
+    ydual = f(xdual2, contexts_dual...)
     return myderivative(T, myderivative(T2, ydual))
 end
 
@@ -568,12 +616,14 @@ function DI.second_derivative!(
     ::DI.NoSecondDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, one(x))
     T2 = tag_type(f, backend, xdual)
-    ydual = f(make_dual(T2, xdual, one(xdual)), map(DI.unwrap, contexts)...)
+    xdual2 = make_dual(T2, xdual, one(xdual))
+    contexts_dual = translate(typeof(xdual2), contexts)
+    ydual = f(xdual2, contexts_dual...)
     return myderivative!(T, der2, myderivative(T2, ydual))
 end
 
@@ -582,12 +632,14 @@ function DI.value_derivative_and_second_derivative(
     ::DI.NoSecondDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, one(x))
     T2 = tag_type(f, backend, xdual)
-    ydual = f(make_dual(T2, xdual, one(xdual)), map(DI.unwrap, contexts)...)
+    xdual2 = make_dual(T2, xdual, one(xdual))
+    contexts_dual = translate(typeof(xdual2), contexts)
+    ydual = f(xdual2, contexts_dual...)
     y = myvalue(T, myvalue(T2, ydual))
     der = myderivative(T, myvalue(T2, ydual))
     der2 = myderivative(T, myderivative(T2, ydual))
@@ -601,12 +653,14 @@ function DI.value_derivative_and_second_derivative!(
     ::DI.NoSecondDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     T = tag_type(f, backend, x)
     xdual = make_dual(T, x, one(x))
     T2 = tag_type(f, backend, xdual)
-    ydual = f(make_dual(T2, xdual, one(xdual)), map(DI.unwrap, contexts)...)
+    xdual2 = make_dual(T2, xdual, one(xdual))
+    contexts_dual = translate(typeof(xdual2), contexts)
+    ydual = f(xdual2, contexts_dual...)
     y = myvalue(T, myvalue(T2, ydual))
     myderivative!(T, der, myvalue(T2, ydual))
     myderivative!(T, der2, myderivative(T2, ydual))
@@ -615,12 +669,9 @@ end
 
 ## HVP
 
+#=
 function DI.prepare_hvp(
-    f::F,
-    backend::AutoForwardDiff,
-    x,
-    tx::NTuple,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff, x, tx::NTuple, contexts::Vararg{DI.Context,C}
 ) where {F,C}
     return DI.prepare_hvp(f, DI.SecondOrder(backend, backend), x, tx, contexts...)
 end
@@ -631,7 +682,7 @@ function DI.hvp(
     backend::AutoForwardDiff,
     x,
     tx::NTuple,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     return DI.hvp(f, prep, DI.SecondOrder(backend, backend), x, tx, contexts...)
 end
@@ -643,7 +694,7 @@ function DI.hvp!(
     backend::AutoForwardDiff,
     x,
     tx::NTuple,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     return DI.hvp!(f, tg, prep, DI.SecondOrder(backend, backend), x, tx, contexts...)
 end
@@ -654,7 +705,7 @@ function DI.gradient_and_hvp(
     backend::AutoForwardDiff,
     x,
     tx::NTuple,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     return DI.gradient_and_hvp(
         f, prep, DI.SecondOrder(backend, backend), x, tx, contexts...
@@ -669,25 +720,26 @@ function DI.gradient_and_hvp!(
     backend::AutoForwardDiff,
     x,
     tx::NTuple,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
     return DI.gradient_and_hvp!(
         f, grad, tg, prep, DI.SecondOrder(backend, backend), x, tx, contexts...
     )
 end
+=#
 
 ## Hessian
 
 ### Unprepared, only when chunk size and tag are not specified
 
 function DI.hessian!(
-    f::F,
-    hess,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, hess, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         return hessian!(hess, fc, x)
     else
@@ -697,12 +749,13 @@ function DI.hessian!(
 end
 
 function DI.hessian(
-    f::F,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         return hessian(fc, x)
     else
@@ -717,9 +770,13 @@ function DI.value_gradient_and_hessian!(
     hess,
     backend::AutoForwardDiff{chunksize,T},
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         result = DiffResult(one(eltype(x)), (grad, hess))
         result = hessian!(result, fc, x)
@@ -734,12 +791,13 @@ function DI.value_gradient_and_hessian!(
 end
 
 function DI.value_gradient_and_hessian(
-    f::F,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f::F, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc = DI.with_contexts(f, contexts...)
         result = HessianResult(x)
         result = hessian!(result, fc, x)
@@ -752,21 +810,22 @@ end
 
 ### Prepared
 
-struct ForwardDiffHessianPrep{C1,C2} <: DI.HessianPrep
+struct ForwardDiffHessianPrep{C1,C2,CD} <: DI.HessianPrep
     array_config::C1
     result_config::C2
+    contexts_dual::CD
 end
 
 function DI.prepare_hessian(
-    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.ConstantOrFunctionOrBackend,C}
+    f::F, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
     chunk = choose_chunk(backend, x)
     tag = get_tag(f, backend, x)
     result = HessianResult(x)
-    array_config = HessianConfig(fc, x, chunk, tag)
-    result_config = HessianConfig(fc, result, x, chunk, tag)
-    return ForwardDiffHessianPrep(array_config, result_config)
+    array_config = HessianConfig(nothing, x, chunk, tag)
+    result_config = HessianConfig(nothing, result, x, chunk, tag)
+    contexts_dual = translate_toprep(dual_type(array_config), contexts)
+    return ForwardDiffHessianPrep(array_config, result_config, contexts_dual)
 end
 
 function DI.hessian!(
@@ -775,9 +834,10 @@ function DI.hessian!(
     prep::ForwardDiffHessianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.array_config, f, x)
@@ -790,9 +850,10 @@ function DI.hessian(
     prep::ForwardDiffHessianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.array_config, f, x)
@@ -807,9 +868,10 @@ function DI.value_gradient_and_hessian!(
     prep::ForwardDiffHessianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     result = DiffResult(one(eltype(x)), (grad, hess))
     CHK = tag_type(backend) === Nothing
     if CHK
@@ -827,9 +889,10 @@ function DI.value_gradient_and_hessian(
     prep::ForwardDiffHessianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc = DI.with_contexts(f, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc = DI.FixTail(f, contexts_dual...)
     result = HessianResult(x)
     CHK = tag_type(backend) === Nothing
     if CHK
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/twoarg.jl
index 291f96887..8acb1d9a0 100644
--- a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/twoarg.jl
+++ b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/twoarg.jl
@@ -1,18 +1,22 @@
 ## Pushforward
 
-struct ForwardDiffTwoArgPushforwardPrep{T,X,Y} <: DI.PushforwardPrep
+struct ForwardDiffTwoArgPushforwardPrep{T,X,Y,CD} <: DI.PushforwardPrep
     xdual_tmp::X
     ydual_tmp::Y
+    contexts_dual::CD
 end
 
 function DI.prepare_pushforward(
-    f!::F, y, backend::AutoForwardDiff, x, tx::NTuple, contexts::Vararg{DI.Context,C}
-) where {F,C}
+    f!::F, y, backend::AutoForwardDiff, x, tx::NTuple{B}, contexts::Vararg{DI.Context,C}
+) where {F,B,C}
     T = tag_type(f!, backend, x)
     xdual_tmp = make_dual_similar(T, x, tx)
-    ydual_tmp = make_dual_similar(T, y, tx)  # dx only for batch size
-    return ForwardDiffTwoArgPushforwardPrep{T,typeof(xdual_tmp),typeof(ydual_tmp)}(
-        xdual_tmp, ydual_tmp
+    ydual_tmp = make_dual_similar(T, y, tx)  # tx only for batch size
+    contexts_dual = translate_toprep(eltype(xdual_tmp), contexts)
+    return ForwardDiffTwoArgPushforwardPrep{
+        T,typeof(xdual_tmp),typeof(ydual_tmp),typeof(contexts_dual)
+    }(
+        xdual_tmp, ydual_tmp, contexts_dual
     )
 end
 
@@ -26,7 +30,7 @@ function compute_ydual_twoarg(
 ) where {F,T,B,C}
     (; ydual_tmp) = prep
     xdual_tmp = make_dual(T, x, tx)
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
     f!(ydual_tmp, xdual_tmp, contexts_dual...)
     return ydual_tmp
 end
@@ -41,7 +45,7 @@ function compute_ydual_twoarg(
 ) where {F,T,B,C}
     (; xdual_tmp, ydual_tmp) = prep
     make_dual!(T, xdual_tmp, x, tx)
-    contexts_dual = translate(T, Val(B), contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
     f!(ydual_tmp, xdual_tmp, contexts_dual...)
     return ydual_tmp
 end
@@ -111,13 +115,9 @@ end
 ### Unprepared, only when tag is not specified
 
 function DI.value_and_derivative(
-    f!::F,
-    y,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if T === Nothing
+    if (T === Nothing && contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend})
         fc! = DI.with_contexts(f!, contexts...)
         result = MutableDiffResult(y, (similar(y),))
         result = derivative!(result, fc!, y, x)
@@ -129,14 +129,9 @@ function DI.value_and_derivative(
 end
 
 function DI.value_and_derivative!(
-    f!::F,
-    y,
-    der,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, der, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if T === Nothing
+    if (T === Nothing && contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend})
         fc! = DI.with_contexts(f!, contexts...)
         result = MutableDiffResult(y, (der,))
         result = derivative!(result, fc!, y, x)
@@ -148,13 +143,9 @@ function DI.value_and_derivative!(
 end
 
 function DI.derivative(
-    f!::F,
-    y,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if T === Nothing
+    if (T === Nothing && contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend})
         fc! = DI.with_contexts(f!, contexts...)
         return derivative(fc!, y, x)
     else
@@ -164,14 +155,9 @@ function DI.derivative(
 end
 
 function DI.derivative!(
-    f!::F,
-    y,
-    der,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, der, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if T === Nothing
+    if (T === Nothing && contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend})
         fc! = DI.with_contexts(f!, contexts...)
         return derivative!(der, fc!, y, x)
     else
@@ -182,21 +168,18 @@ end
 
 ### Prepared
 
-struct ForwardDiffTwoArgDerivativePrep{C} <: DI.DerivativePrep
+struct ForwardDiffTwoArgDerivativePrep{C,CD} <: DI.DerivativePrep
     config::C
+    contexts_dual::CD
 end
 
 function DI.prepare_derivative(
-    f!::F,
-    y,
-    backend::AutoForwardDiff,
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
     tag = get_tag(f!, backend, x)
-    config = DerivativeConfig(fc!, y, x, tag)
-    return ForwardDiffTwoArgDerivativePrep(config)
+    config = DerivativeConfig(nothing, y, x, tag)
+    contexts_dual = translate_toprep(dual_type(config), contexts)
+    return ForwardDiffTwoArgDerivativePrep(config, contexts_dual)
 end
 
 function DI.prepare!_derivative(
@@ -222,9 +205,10 @@ function DI.value_and_derivative(
     prep::ForwardDiffTwoArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     result = MutableDiffResult(y, (similar(y),))
     CHK = tag_type(backend) === Nothing
     if CHK
@@ -241,9 +225,10 @@ function DI.value_and_derivative!(
     prep::ForwardDiffTwoArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     result = MutableDiffResult(y, (der,))
     CHK = tag_type(backend) === Nothing
     if CHK
@@ -259,9 +244,10 @@ function DI.derivative(
     prep::ForwardDiffTwoArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f!, x)
@@ -276,9 +262,10 @@ function DI.derivative!(
     prep::ForwardDiffTwoArgDerivativePrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f!, x)
@@ -291,13 +278,13 @@ end
 ### Unprepared, only when chunk size and tag are not specified
 
 function DI.value_and_jacobian(
-    f!::F,
-    y,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc! = DI.with_contexts(f!, contexts...)
         jac = similar(y, length(y), length(x))
         result = MutableDiffResult(y, (jac,))
@@ -310,14 +297,13 @@ function DI.value_and_jacobian(
 end
 
 function DI.value_and_jacobian!(
-    f!::F,
-    y,
-    jac,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, jac, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc! = DI.with_contexts(f!, contexts...)
         result = MutableDiffResult(y, (jac,))
         result = jacobian!(result, fc!, y, x)
@@ -329,13 +315,13 @@ function DI.value_and_jacobian!(
 end
 
 function DI.jacobian(
-    f!::F,
-    y,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc! = DI.with_contexts(f!, contexts...)
         return jacobian(fc!, y, x)
     else
@@ -345,14 +331,13 @@ function DI.jacobian(
 end
 
 function DI.jacobian!(
-    f!::F,
-    y,
-    jac,
-    backend::AutoForwardDiff{chunksize,T},
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, jac, backend::AutoForwardDiff{chunksize,T}, x, contexts::Vararg{DI.Context,C}
 ) where {F,C,chunksize,T}
-    if isnothing(chunksize) && T === Nothing
+    if (
+        isnothing(chunksize) &&
+        T === Nothing &&
+        contexts isa NTuple{C,DI.ConstantOrFunctionOrBackend}
+    )
         fc! = DI.with_contexts(f!, contexts...)
         return jacobian!(jac, fc!, y, x)
     else
@@ -363,22 +348,19 @@ end
 
 ### Prepared
 
-struct ForwardDiffTwoArgJacobianPrep{C} <: DI.JacobianPrep
+struct ForwardDiffTwoArgJacobianPrep{C,CD} <: DI.JacobianPrep
     config::C
+    contexts_dual::CD
 end
 
 function DI.prepare_jacobian(
-    f!::F,
-    y,
-    backend::AutoForwardDiff,
-    x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    f!::F, y, backend::AutoForwardDiff, x, contexts::Vararg{DI.Context,C}
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
     chunk = choose_chunk(backend, x)
     tag = get_tag(f!, backend, x)
-    config = JacobianConfig(fc!, y, x, chunk, tag)
-    return ForwardDiffTwoArgJacobianPrep(config)
+    config = JacobianConfig(nothing, y, x, chunk, tag)
+    contexts_dual = translate_toprep(dual_type(config), contexts)
+    return ForwardDiffTwoArgJacobianPrep(config, contexts_dual)
 end
 
 function DI.prepare!_jacobian(
@@ -406,9 +388,10 @@ function DI.value_and_jacobian(
     prep::ForwardDiffTwoArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     jac = similar(y, length(y), length(x))
     result = MutableDiffResult(y, (jac,))
     CHK = tag_type(backend) === Nothing
@@ -426,9 +409,10 @@ function DI.value_and_jacobian!(
     prep::ForwardDiffTwoArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     result = MutableDiffResult(y, (jac,))
     CHK = tag_type(backend) === Nothing
     if CHK
@@ -444,9 +428,10 @@ function DI.jacobian(
     prep::ForwardDiffTwoArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f!, x)
@@ -461,9 +446,10 @@ function DI.jacobian!(
     prep::ForwardDiffTwoArgJacobianPrep,
     backend::AutoForwardDiff,
     x,
-    contexts::Vararg{DI.ConstantOrFunctionOrBackend,C},
+    contexts::Vararg{DI.Context,C},
 ) where {F,C}
-    fc! = DI.with_contexts(f!, contexts...)
+    contexts_dual = translate_prepared(contexts, prep.contexts_dual)
+    fc! = DI.FixTail(f!, contexts_dual...)
     CHK = tag_type(backend) === Nothing
     if CHK
         checktag(prep.config, f!, x)
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/utils.jl b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/utils.jl
index 2c53d17e2..ed8393576 100644
--- a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/utils.jl
+++ b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/utils.jl
@@ -1,5 +1,5 @@
 function DI.pick_batchsize(::AutoForwardDiff{nothing}, N::Integer)
-    chunksize = ForwardDiff.pickchunksize(N)
+    chunksize = pickchunksize(N)
     return DI.BatchSizeSettings{chunksize}(N)
 end
 
@@ -26,6 +26,11 @@ end
 tag_type(::AutoForwardDiff{chunksize,T}) where {chunksize,T} = T
 tag_type(f::F, backend::AutoForwardDiff, x) where {F} = typeof(get_tag(f, backend, x))
 
+dual_type(config::DerivativeConfig) = eltype(config.duals)
+dual_type(config::GradientConfig) = eltype(config.duals)
+dual_type(config::JacobianConfig{T,V,N}) where {T,V,N} = Dual{T,V,N}
+dual_type(config::HessianConfig) = dual_type(config.gradient_config)
+
 function make_dual_similar(::Type{T}, x::Number, tx::NTuple{B}) where {T,B}
     return Dual{T}(x, tx...)
 end
@@ -82,19 +87,42 @@ struct PrepContext{T<:DI.Prep} <: DI.Context
     data::T
 end
 
-function _translate(::Type{T}, ::Val{B}, c::DI.ConstantOrFunctionOrBackend) where {T,B}
-    return DI.unwrap(c)
+NotCache = Union{DI.ConstantOrFunctionOrBackend,PrepContext}
+
+_translate(::Type{D}, c::NotCache) where {D<:Dual} = DI.unwrap(c)
+function _translate(::Type{D}, c::DI.Cache) where {D<:Dual}
+    c0 = DI.unwrap(c)
+    return similar(c0, D)
 end
-_translate(::Type{T}, ::Val{B}, c::PrepContext) where {T,B} = DI.unwrap(c)
 
-function _translate(::Type{T}, ::Val{B}, c::DI.Cache) where {T,B}
+function translate(::Type{D}, contexts::NTuple{C,DI.Context}) where {D<:Dual,C}
+    new_contexts = map(contexts) do c
+        _translate(D, c)
+    end
+    return new_contexts
+end
+
+_translate_toprep(::Type{D}, c::NotCache) where {D<:Dual} = nothing
+function _translate_toprep(::Type{D}, c::DI.Cache) where {D<:Dual}
     c0 = DI.unwrap(c)
-    return make_dual(T, c0, ntuple(_ -> similar(c0), Val(B)))  # TODO: optimize
+    return similar(c0, D)
 end
 
-function translate(::Type{T}, ::Val{B}, contexts::Vararg{DI.Context,C}) where {T,B,C}
+function translate_toprep(::Type{D}, contexts::NTuple{C,DI.Context}) where {D<:Dual,C}
     new_contexts = map(contexts) do c
-        _translate(T, Val(B), c)
+        _translate_toprep(D, c)
+    end
+    return new_contexts
+end
+
+_translate_prepared(c::NotCache, _pc) = DI.unwrap(c)
+_translate_prepared(_c::DI.Cache, pc) = pc
+
+function translate_prepared(
+    contexts::NTuple{C,DI.Context}, prep_contexts::NTuple{C,Any}
+) where {C}
+    new_contexts = map(contexts, prep_contexts) do c, pc
+        _translate_prepared(c, pc)
     end
     return new_contexts
 end
diff --git a/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/onearg.jl
index 8f67ad78d..dde2203ab 100644
--- a/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/onearg.jl
+++ b/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/onearg.jl
@@ -288,6 +288,7 @@ end
 
 ## HVP
 
+#=
 function DI.prepare_hvp(
     f, backend::AutoPolyesterForwardDiff, x, tx::NTuple, contexts::Vararg{DI.Context,C}
 ) where {C}
@@ -357,6 +358,7 @@ function DI.gradient_and_hvp!(
         contexts...,
     )
 end
+=#
 
 ## Second derivative
 
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceSparseConnectivityTracerExt/DifferentiationInterfaceSparseConnectivityTracerExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceSparseConnectivityTracerExt/DifferentiationInterfaceSparseConnectivityTracerExt.jl
index 80508c511..f5a315c3a 100644
--- a/DifferentiationInterface/ext/DifferentiationInterfaceSparseConnectivityTracerExt/DifferentiationInterfaceSparseConnectivityTracerExt.jl
+++ b/DifferentiationInterface/ext/DifferentiationInterfaceSparseConnectivityTracerExt/DifferentiationInterfaceSparseConnectivityTracerExt.jl
@@ -36,7 +36,7 @@ function DI.jacobian_sparsity_with_contexts(
     contexts::Vararg{DI.Context,C},
 ) where {F,C}
     contexts_tracer = jacobian_translate(detector, contexts...)
-    fc = DI.FixTail(f, contexts_tracer)
+    fc = DI.FixTail(f, contexts_tracer...)
     return jacobian_sparsity(fc, x, detector)
 end
 
@@ -48,7 +48,7 @@ function DI.jacobian_sparsity_with_contexts(
     contexts::Vararg{DI.Context,C},
 ) where {F,C}
     contexts_tracer = jacobian_translate(detector, contexts...)
-    fc! = DI.FixTail(f!, contexts_tracer)
+    fc! = DI.FixTail(f!, contexts_tracer...)
     return jacobian_sparsity(fc!, y, x, detector)
 end
 
@@ -59,7 +59,7 @@ function DI.hessian_sparsity_with_contexts(
     contexts::Vararg{DI.Context,C},
 ) where {F,C}
     contexts_tracer = hessian_translate(detector, contexts...)
-    fc = DI.FixTail(f, contexts_tracer)
+    fc = DI.FixTail(f, contexts_tracer...)
     return hessian_sparsity(fc, x, detector)
 end
 
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceZygoteExt/DifferentiationInterfaceZygoteExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceZygoteExt/DifferentiationInterfaceZygoteExt.jl
index 6762738a1..c5214c666 100644
--- a/DifferentiationInterface/ext/DifferentiationInterfaceZygoteExt/DifferentiationInterfaceZygoteExt.jl
+++ b/DifferentiationInterface/ext/DifferentiationInterfaceZygoteExt/DifferentiationInterfaceZygoteExt.jl
@@ -158,7 +158,12 @@ function DI.prepare_hvp(
 end
 
 function DI.hvp(
-    f, prep::DI.HVPPrep, backend::AutoZygote, x, tx::NTuple, contexts::Vararg{DI.Context,C}
+    f,
+    prep::DI.ForwardOverReverseHVPPrep,
+    backend::AutoZygote,
+    x,
+    tx::NTuple,
+    contexts::Vararg{DI.Context,C},
 ) where {C}
     return DI.hvp(f, prep, DI.SecondOrder(AutoForwardDiff(), backend), x, tx, contexts...)
 end
@@ -166,7 +171,7 @@ end
 function DI.hvp!(
     f,
     tg::NTuple,
-    prep::DI.HVPPrep,
+    prep::DI.ForwardOverReverseHVPPrep,
     backend::AutoZygote,
     x,
     tx::NTuple,
@@ -178,7 +183,12 @@ function DI.hvp!(
 end
 
 function DI.gradient_and_hvp(
-    f, prep::DI.HVPPrep, backend::AutoZygote, x, tx::NTuple, contexts::Vararg{DI.Context,C}
+    f,
+    prep::DI.ForwardOverReverseHVPPrep,
+    backend::AutoZygote,
+    x,
+    tx::NTuple,
+    contexts::Vararg{DI.Context,C},
 ) where {C}
     return DI.gradient_and_hvp(
         f, prep, DI.SecondOrder(AutoForwardDiff(), backend), x, tx, contexts...
@@ -189,7 +199,7 @@ function DI.gradient_and_hvp!(
     f,
     grad,
     tg::NTuple,
-    prep::DI.HVPPrep,
+    prep::DI.ForwardOverReverseHVPPrep,
     backend::AutoZygote,
     x,
     tx::NTuple,
diff --git a/DifferentiationInterface/src/utils/context.jl b/DifferentiationInterface/src/utils/context.jl
index 15a9d4a0e..af8d1f622 100644
--- a/DifferentiationInterface/src/utils/context.jl
+++ b/DifferentiationInterface/src/utils/context.jl
@@ -1,6 +1,9 @@
 struct FixTail{F,A<:Tuple}
     f::F
     tail_args::A
+    function FixTail(f::F, tail_args::Vararg{Any,N}) where {F,N}
+        return new{F,typeof(tail_args)}(f, tail_args)
+    end
 end
 
 function (ft::FixTail)(args::Vararg{Any,N}) where {N}
@@ -113,5 +116,5 @@ with_contexts(f) = f
 
 function with_contexts(f::F, contexts::Vararg{Context,N}) where {F,N}
     tail_args = map(unwrap, contexts)
-    return FixTail(f, tail_args)
+    return FixTail(f, tail_args...)
 end
diff --git a/DifferentiationInterface/test/Back/ForwardDiff/test.jl b/DifferentiationInterface/test/Back/ForwardDiff/test.jl
index f4024afbd..6d5209833 100644
--- a/DifferentiationInterface/test/Back/ForwardDiff/test.jl
+++ b/DifferentiationInterface/test/Back/ForwardDiff/test.jl
@@ -42,7 +42,11 @@ end
     )
 
     test_differentiation(
-        AutoForwardDiff(); correctness=false, type_stability=:prepared, logging=LOGGING
+        AutoForwardDiff();
+        correctness=false,
+        type_stability=:prepared,
+        excluded=[:hvp],  # TODO: toggle
+        logging=LOGGING,
     )
 
     test_differentiation(