diff --git a/ext/ReactantAbstractFFTsExt.jl b/ext/ReactantAbstractFFTsExt.jl
index c29bbad9fb..3b5aeff7ee 100644
--- a/ext/ReactantAbstractFFTsExt.jl
+++ b/ext/ReactantAbstractFFTsExt.jl
@@ -7,7 +7,7 @@ using Reactant.Ops: @opcall
 
 # FFTW.jl defines methods on StridedArrays, and we have to be more specific than FFTW to
 # catch its methods.
-const AnyStridedTracedRArray{T,N} = StridedArray{TracedRNumber{T},N}
+const AnyStridedTracedRArray{T,N} = StridedArray{<:TracedRNumber{T},N}
 
 # To automatically convert FFT plans to traced versions
 # To extend a user needs to extend Reactant.reactant_fftplan for their plan type
diff --git a/ext/ReactantCUDAExt.jl b/ext/ReactantCUDAExt.jl
index 43d322984f..35ea0098a2 100644
--- a/ext/ReactantCUDAExt.jl
+++ b/ext/ReactantCUDAExt.jl
@@ -144,7 +144,7 @@ Base.OneTo(x::CuTracedRNumber{<:Integer}) = Base.OneTo(x[])
     end
 end
 
-@inline function Base.convert(CT::Type{CuTracedRNumber{Float64,1}}, x::Number)
+@inline function Base.convert(CT::Type{<:CuTracedRNumber{Float64,1}}, x::Number)
     return CT(
         Base.reinterpret(
             Core.LLVMPtr{Float64,1},
@@ -168,7 +168,7 @@ end
     )
 end
 
-@inline function Base.convert(CT::Type{CuTracedRNumber{Float32,1}}, x::Number)
+@inline function Base.convert(CT::Type{<:CuTracedRNumber{Float32,1}}, x::Number)
     return CT(
         Base.reinterpret(
             Core.LLVMPtr{Float32,1},
diff --git a/ext/ReactantSparseArraysExt/Errors.jl b/ext/ReactantSparseArraysExt/Errors.jl
index 23622e62cd..5f8de6b426 100644
--- a/ext/ReactantSparseArraysExt/Errors.jl
+++ b/ext/ReactantSparseArraysExt/Errors.jl
@@ -1,15 +1,15 @@
 # We don't yet support sparse arrays. Throwing errors on this dispatches to avoid
 # ambiguities.
-function Base.getindex(::AbstractSparseArray{TracedRNumber{T},N,1}, ::Int64) where {T,N}
+function Base.getindex(::AbstractSparseArray{<:TracedRNumber{T},N,1}, ::Int64) where {T,N}
     return error("Sparse arrays are not supported by reactant yet.")
 end
 
 function Base.getindex(
-    ::AbstractSparseMatrixCSC{TracedRNumber{T}}, ::Int64, ::Int64
+    ::AbstractSparseMatrixCSC{<:TracedRNumber{T}}, ::Int64, ::Int64
 ) where {T}
     return error("Sparse arrays are not supported by reactant yet.")
 end
 
-function Base.getindex(::CHOLMOD.Sparse{TracedRNumber{T}}, ::Int64, ::Int64) where {T}
+function Base.getindex(::CHOLMOD.Sparse{<:TracedRNumber{T}}, ::Int64, ::Int64) where {T}
     return error("Sparse arrays are not supported by reactant yet.")
 end
diff --git a/ext/ReactantSparseArraysExt/ReadOnly.jl b/ext/ReactantSparseArraysExt/ReadOnly.jl
index 90b3bb7f9d..6c8630300c 100644
--- a/ext/ReactantSparseArraysExt/ReadOnly.jl
+++ b/ext/ReactantSparseArraysExt/ReadOnly.jl
@@ -1,48 +1,48 @@
 function Base.getindex(
-    A::ReadOnly{Reactant.TracedRNumber{T},1,V}, inds::AbstractArray
-) where {T,V<:AbstractArray{Reactant.TracedRNumber{T},1}}
+    A::ReadOnly{<:Reactant.TracedRNumber{T},1,V}, inds::AbstractArray
+) where {T,V<:AbstractArray{<:Reactant.TracedRNumber{T},1}}
     return getindex(parent(A), inds)
 end
 
 function Base.getindex(
-    A::ReadOnly{Reactant.TracedRNumber{T},1,V}, ::Colon
-) where {T,V<:AbstractArray{Reactant.TracedRNumber{T},1}}
+    A::ReadOnly{<:Reactant.TracedRNumber{T},1,V}, ::Colon
+) where {T,V<:AbstractArray{<:Reactant.TracedRNumber{T},1}}
     return getindex(parent(A), :)
 end
 
 function Base.getindex(
-    A::ReadOnly{Reactant.TracedRNumber{T},N,V},
+    A::ReadOnly{<:Reactant.TracedRNumber{T},N,V},
     i::Union{Integer,Reactant.TracedRNumber{<:Integer}},
-) where {T,N,V<:AbstractArray{Reactant.TracedRNumber{T},N}}
+) where {T,N,V<:AbstractArray{<:Reactant.TracedRNumber{T},N}}
     return getindex(parent(A), i)
 end
 
 function Base.getindex(
-    A::ReadOnly{Reactant.TracedRNumber{T},N,V}, inds::AbstractArray
-) where {T,N,V<:AbstractArray{Reactant.TracedRNumber{T},N}}
+    A::ReadOnly{<:Reactant.TracedRNumber{T},N,V}, inds::AbstractArray
+) where {T,N,V<:AbstractArray{<:Reactant.TracedRNumber{T},N}}
     return getindex(parent(A), inds)
 end
 
 function Base.getindex(
-    A::ReadOnly{Reactant.TracedRNumber{T},N,V}, idx::CartesianIndex{N}
-) where {T,N,V<:AbstractArray{Reactant.TracedRNumber{T},N}}
+    A::ReadOnly{<:Reactant.TracedRNumber{T},N,V}, idx::CartesianIndex{N}
+) where {T,N,V<:AbstractArray{<:Reactant.TracedRNumber{T},N}}
     return getindex(parent(A), idx)
 end
 
 function Base.getindex(
-    A::ReadOnly{Reactant.TracedRNumber{T},1,V}, idx::CartesianIndex{1}
-) where {T,V<:AbstractArray{Reactant.TracedRNumber{T},1}}
+    A::ReadOnly{<:Reactant.TracedRNumber{T},1,V}, idx::CartesianIndex{1}
+) where {T,V<:AbstractArray{<:Reactant.TracedRNumber{T},1}}
     return getindex(parent(A), idx)
 end
 
 function Base.getindex(
-    A::ReadOnly{Reactant.TracedRNumber{T},N,V}, ::Colon
-) where {T,N,V<:AbstractArray{Reactant.TracedRNumber{T},N}}
+    A::ReadOnly{<:Reactant.TracedRNumber{T},N,V}, ::Colon
+) where {T,N,V<:AbstractArray{<:Reactant.TracedRNumber{T},N}}
     return getindex(parent(A), :)
 end
 
 function Base.getindex(
-    x::ReadOnly{TracedRNumber{T},N},
+    x::ReadOnly{<:TracedRNumber{T},N},
     idx::Vararg{Union{Integer,Reactant.TracedRNumber{<:Integer}},N},
 ) where {T,N}
     return getindex(parent(x), idx...)
@@ -51,14 +51,14 @@ end
 function Base.getindex(
     x::SparseArrays.ReadOnly{Reactant.TracedRNumber{T},1,V},
     idx::Union{Int64,Reactant.TracedRNumber{Int64}},
-) where {T,V<:AbstractArray{Reactant.TracedRNumber{T},1}}
+) where {T,V<:AbstractArray{<:Reactant.TracedRNumber{T},1}}
     return getindex(parent(x), idx)
 end
 
 function Base.getindex(
     x::SparseArrays.ReadOnly{
         Reactant.TracedRNumber{T},N,V
-    } where {V<:AbstractArray{Reactant.TracedRNumber{T},N}},
+    } where {V<:AbstractArray{<:Reactant.TracedRNumber{T},N}},
     idx::Vararg{Union{Int64,Reactant.TracedRNumber{Int64}},N},
 ) where {T,N}
     return getindex(parent(x), idx...)
diff --git a/lib/ReactantCore/src/ReactantCore.jl b/lib/ReactantCore/src/ReactantCore.jl
index 17aeb3fc92..18e2ea26ea 100644
--- a/lib/ReactantCore/src/ReactantCore.jl
+++ b/lib/ReactantCore/src/ReactantCore.jl
@@ -886,7 +886,7 @@ end
 """
     materialize_traced_array(AbstractArray{<:TracedRNumber})::TracedRArray
 
-Given an AbstractArray{TracedRNumber}, return or create an equivalent TracedRArray.
+Given an AbstractArray{<:TracedRNumber}, return or create an equivalent TracedRArray.
 
 """
 function materialize_traced_array end
diff --git a/src/ConcreteRArray.jl b/src/ConcreteRArray.jl
index 414ea4222c..cc341ded46 100644
--- a/src/ConcreteRArray.jl
+++ b/src/ConcreteRArray.jl
@@ -484,6 +484,15 @@ end
 
 Base.similar(a::ConcretePJRTArray, dims::Dims) = similar(a, eltype(a), dims)
 
+# A concrete array asked for a traced element type (e.g. via LinearAlgebra's
+# generic `similar`/`\` while tracing) cannot hold traced values in its device
+# buffer, so produce a traced array instead.
+function Base.similar(
+    ::ConcretePJRTArray{T,N,D}, ::Type{S}, dims::Dims
+) where {S<:TracedRNumber,T,N,D}
+    return similar(TracedRArray{unwrapped_eltype(S)}, dims)
+end
+
 function Base.similar(AT::Type{<:ConcretePJRTArray{T}}, dims::Dims; kwargs...) where {T}
     return similar(AT, T, dims; kwargs...)
 end
@@ -493,6 +502,11 @@ function Base.similar(a::ConcreteIFRTArray{T}, ::Type{S}=T, dims::Dims=size(a))
         Array{S}(undef, dims); client=XLA.client(a), device=XLA.device(a), a.sharding
     )
 end
+function Base.similar(
+    ::ConcreteIFRTArray{T}, ::Type{S}, dims::Dims
+) where {S<:TracedRNumber,T}
+    return similar(TracedRArray{unwrapped_eltype(S)}, dims)
+end
 Base.similar(a::ConcreteIFRTArray, dims::Dims) = similar(a, eltype(a), dims)
 function Base.similar(::Type{ConcreteIFRTArray{T}}, dims::Dims) where {T}
     return ConcreteIFRTArray{T}(undef, dims)
@@ -725,8 +739,8 @@ for aType in (:ConcretePJRTArray, :ConcreteIFRTArray)
         end
 
         function Base.copyto!(
-            dest::SubArray{TracedRNumber{T1},<:Any,<:$(aType)},
-            src::SubArray{TracedRNumber{T2},<:Any,<:Array},
+            dest::SubArray{<:TracedRNumber{T1},<:Any,<:$(aType)},
+            src::SubArray{<:TracedRNumber{T2},<:Any,<:Array},
         ) where {T1,T2}
             throw(MethodError(copyto!, (dest, src)))
         end
@@ -771,7 +785,7 @@ function Base.zero(x::ConcreteIFRTArray{T,N}) where {T,N}
 end
 
 function Base.fill!(
-    a::ConcretePJRTArray{TracedRNumber{T},N}, val::TracedRNumber{T2}
+    a::ConcretePJRTArray{<:TracedRNumber{T},N}, val::TracedRNumber{T2}
 ) where {T,T2,N}
     throw(MethodError(fill!, (a, val)))
 end
@@ -805,7 +819,7 @@ function Base.fill!(a::ConcreteIFRTArray{T,N}, val) where {T,N}
 end
 
 function Base.fill!(
-    a::ConcreteIFRTArray{TracedRNumber{T},N}, val::TracedRNumber{T2}
+    a::ConcreteIFRTArray{<:TracedRNumber{T},N}, val::TracedRNumber{T2}
 ) where {T,T2,N}
     throw(MethodError(fill!, (a, val)))
 end
diff --git a/src/Indexing.jl b/src/Indexing.jl
index 7768a1448b..e3f664baf9 100644
--- a/src/Indexing.jl
+++ b/src/Indexing.jl
@@ -77,7 +77,7 @@ end
 
 # This method is needed exclusively to resolve an ambiguity
 function Base.getindex(
-    l::Selectors.List{TracedRNumber{T}}, index::Union{Int,TracedRNumber{Int}}
+    l::Selectors.List{<:TracedRNumber{T}}, index::Union{Int,TracedRNumber{Int}}
 ) where {T}
     return getindex(Reactant.promote_to(TracedRArray{T,1}, l), index)
 end
@@ -173,8 +173,8 @@ end
 
 ### Specialize certain dispatches for better codegen
 for aType in (
-    Base.ReshapedArray{TracedRNumber{T}} where {T},
-    PermutedDimsArray{TracedRNumber{T}} where {T},
+    Base.ReshapedArray{<:TracedRNumber{T}} where {T},
+    PermutedDimsArray{<:TracedRNumber{T}} where {T},
 )
     @eval begin
         function Base.getindex(a::$(aType), indices::Union{Int,TracedRNumber{Int}}...)
@@ -188,8 +188,8 @@ for aType in (
 end
 
 for aType in (
-    Base.ReshapedArray{TracedRNumber{T},N,P,Tuple{}} where {T,N,P<:AbstractArray},
-    Base.ReshapedArray{TracedRNumber{T},1,P,Tuple{}} where {T,P<:AbstractArray},
+    Base.ReshapedArray{<:TracedRNumber{T},N,P,Tuple{}} where {T,N,P<:AbstractArray},
+    Base.ReshapedArray{<:TracedRNumber{T},1,P,Tuple{}} where {T,P<:AbstractArray},
 )
     @eval function Base.getindex(a::$(aType), indices::Int)
         return getindex(materialize_traced_array(a), indices)
@@ -197,7 +197,7 @@ for aType in (
 end
 
 function Base.getindex(
-    x::Base.ReshapedArray{TracedRNumber{T}}, index::Base.ReshapedIndex
+    x::Base.ReshapedArray{<:TracedRNumber{T}}, index::Base.ReshapedIndex
 ) where {T}
     return getindex(parent(x), index.parentindex)
 end
@@ -463,7 +463,7 @@ function generate_index_list(i1, is...)
 end
 
 function scalar_index_to_cartesian(
-    idx::AbstractVector{TracedRNumber{T}}, sz::NTuple{N,Int}
+    idx::AbstractVector{<:TracedRNumber{T}}, sz::NTuple{N,Int}
 ) where {T,N}
     idx = materialize_traced_array(idx)
     idx = @opcall(subtract(idx, @opcall(fill(T(1), size(idx)))))
diff --git a/src/Ops.jl b/src/Ops.jl
index b63482680e..883cce7b46 100644
--- a/src/Ops.jl
+++ b/src/Ops.jl
@@ -355,7 +355,7 @@ function _fill_element_attr(x::Complex)
 end
 
 @noinline function concatenate(
-    inputs::Vector{TracedRArray{T,N}},
+    inputs::Vector{<:TracedRArray{T,N}},
     dimension::Int;
     location=mlir_stacktrace("fill", @__FILE__, @__LINE__),
 ) where {T,N}
@@ -869,7 +869,7 @@ end
 end
 
 function bitcast_convert(
-    ::Type{TracedRArray{U,N}},
+    ::Type{<:TracedRArray{U,N}},
     x::TracedRArray{T,N};
     location=mlir_stacktrace("bitcast_convert", @__FILE__, @__LINE__),
 ) where {T,U,N}
@@ -1738,7 +1738,7 @@ end
 end
 
 @noinline function rng_bit_generator(
-    ::Type{TracedRNumber{T}}, seed::TracedRArray{UInt64,1}, shape; kwargs...
+    ::Type{<:TracedRNumber{T}}, seed::TracedRArray{UInt64,1}, shape; kwargs...
 ) where {T}
     return rng_bit_generator(T, seed, shape; kwargs...)
 end
@@ -1798,7 +1798,7 @@ end
 end
 
 @noinline function randn(
-    ::Type{TracedRNumber{T}}, seed::TracedRArray{UInt64,1}, shape; kwargs...
+    ::Type{<:TracedRNumber{T}}, seed::TracedRArray{UInt64,1}, shape; kwargs...
 ) where {T}
     return randn(T, seed, shape; kwargs...)
 end
@@ -1841,7 +1841,7 @@ distribution with rate 1. Returns a NamedTuple with the following fields:
 end
 
 @noinline function randexp(
-    ::Type{TracedRNumber{T}}, seed::TracedRArray{UInt64,1}, shape; kwargs...
+    ::Type{<:TracedRNumber{T}}, seed::TracedRArray{UInt64,1}, shape; kwargs...
 ) where {T}
     return randexp(T, seed, shape; kwargs...)
 end
@@ -1923,7 +1923,7 @@ end
 
 # eltype conversion
 @noinline function convert(
-    ::Type{TracedRArray{T,N}},
+    ::Type{<:TracedRArray{T,N}},
     x::TracedRArray;
     location=mlir_stacktrace("convert", @__FILE__, @__LINE__),
 ) where {T,N}
@@ -1940,7 +1940,7 @@ end
 end
 
 @noinline function convert(
-    ::Type{TracedRNumber{T}},
+    ::Type{<:TracedRNumber{T}},
     x::TracedRNumber;
     location=mlir_stacktrace("convert", @__FILE__, @__LINE__),
 ) where {T}
@@ -2166,7 +2166,7 @@ end
 
 @noinline function scatter(
     f::F,
-    dest::Vector{TracedRArray{T,N}},
+    dest::Vector{<:TracedRArray{T,N}},
     scatter_indices::TracedRArray{Int64},
     updates::Vector{<:TracedRArray{T}};
     location=mlir_stacktrace("scatter", @__FILE__, @__LINE__),
@@ -2195,7 +2195,7 @@ end
 end
 
 @noinline function scatter(
-    dest::Vector{TracedRArray{T,N}},
+    dest::Vector{<:TracedRArray{T,N}},
     scatter_indices::TracedRArray{TI},
     updates::Vector{<:TracedRArray{T}};
     update_computation::MLIR.IR.Region,
@@ -3967,8 +3967,8 @@ end
 
 @noinline function reduce_window(
     f::F,
-    inputs::Vector{TracedRArray{T,N}},
-    init_values::Vector{TracedRNumber{T}};
+    inputs::Vector{<:TracedRArray{T,N}},
+    init_values::Vector{<:TracedRNumber{T}};
     window_dimensions::Vector{Int},
     window_strides::Vector{Int},
     base_dilations::Vector{Int},
diff --git a/src/TracedPromotion.jl b/src/TracedPromotion.jl
index 765f26fa83..00acc7934f 100644
--- a/src/TracedPromotion.jl
+++ b/src/TracedPromotion.jl
@@ -11,30 +11,30 @@ function promote_to(::Type{TracedRArray{T}}, rhs) where {T}
     return promote_to(TracedRArray{T,ndims(rhs)}, rhs)
 end
 
-promote_to(::Type{TracedRArray{T,N}}, rhs::TracedRArray{T,N}) where {T,N} = rhs
-function promote_to(::Type{TracedRArray{T,N}}, rhs::TracedRArray{T2,N}) where {T,T2,N}
+promote_to(::Type{<:TracedRArray{T,N}}, rhs::TracedRArray{T,N}) where {T,N} = rhs
+function promote_to(::Type{<:TracedRArray{T,N}}, rhs::TracedRArray{T2,N}) where {T,T2,N}
     return @opcall convert(TracedRArray{T,N}, rhs)
 end
 
 function promote_to(
-    ::Type{TracedRArray{T,N}}, rhs::AbstractArray{<:TracedRNumber,N}
+    ::Type{<:TracedRArray{T,N}}, rhs::AbstractArray{<:TracedRNumber,N}
 ) where {T,N}
     return @opcall convert(TracedRArray{T,N}, aos_to_soa(materialize_traced_array(rhs)))
 end
 
-function promote_to(::Type{TracedRArray{T,1}}, rhs::AbstractRange) where {T}
+function promote_to(::Type{<:TracedRArray{T,1}}, rhs::AbstractRange) where {T}
     return @opcall convert(TracedRArray{T,1}, materialize_traced_array(rhs))
 end
 
-function promote_to(::Type{TracedRArray{T,1}}, rhs::Base.OneTo) where {T}
+function promote_to(::Type{<:TracedRArray{T,1}}, rhs::Base.OneTo) where {T}
     return promote_to(TracedRArray{T,1}, first(rhs):last(rhs))
 end
 
-function promote_to(::Type{TracedRArray{T,N}}, rhs::LinearAlgebra.Diagonal) where {T,N}
+function promote_to(::Type{<:TracedRArray{T,N}}, rhs::LinearAlgebra.Diagonal) where {T,N}
     return LinearAlgebra.diagm(promote_to(TracedRArray{T,1}, rhs.diag))
 end
 
-function promote_to(::Type{TracedRArray{T,N}}, rhs::AbstractArray{<:Any,N}) where {T,N}
+function promote_to(::Type{<:TracedRArray{T,N}}, rhs::AbstractArray{<:Any,N}) where {T,N}
     if ancestor(rhs) isa AnyTracedRArray
         return promote_to(TracedRArray{T,N}, materialize_traced_array(rhs))
     end
@@ -42,7 +42,7 @@ function promote_to(::Type{TracedRArray{T,N}}, rhs::AbstractArray{<:Any,N}) wher
     return promote_to(TracedRArray{T,N}, @opcall(constant(rhs)))
 end
 
-function promote_to(::Type{TracedRArray{T,N}}, rhs::Number) where {T,N}
+function promote_to(::Type{<:TracedRArray{T,N}}, rhs::Number) where {T,N}
     return promote_to(TracedRArray{T,N}, [rhs])
 end
 
@@ -58,35 +58,35 @@ function promote_to(
     return promote_to(TracedRNumber{float(unwrapped_eltype(T))}, rhs)
 end
 
-promote_to(::Type{TracedRNumber{T}}, rhs::TracedRNumber{T}) where {T} = rhs
-function promote_to(::Type{TracedRNumber{T}}, rhs::TracedRNumber{T2}) where {T,T2}
+promote_to(::Type{<:TracedRNumber{T}}, rhs::TracedRNumber{T}) where {T} = rhs
+function promote_to(::Type{<:TracedRNumber{T}}, rhs::TracedRNumber{T2}) where {T,T2}
     return @opcall convert(TracedRNumber{T}, rhs)
 end
 function promote_to(
-    ::Type{TracedRNumber{T}}, rhs::TracedRNumber{T2}
+    ::Type{<:TracedRNumber{T}}, rhs::TracedRNumber{T2}
 ) where {T<:ReactantFloat8,T2}
     return @opcall convert(TracedRNumber{T}, rhs)
 end
 
-function promote_to(::Type{TracedRArray{T,0}}, rhs::TracedRNumber{T2}) where {T,T2}
+function promote_to(::Type{<:TracedRArray{T,0}}, rhs::TracedRNumber{T2}) where {T,T2}
     return TracedRArray{T,0}((), @opcall(convert(TracedRNumber{T}, rhs)).mlir_data, ())
 end
-function promote_to(::Type{TracedRNumber{T}}, rhs::TracedRArray{T2,0}) where {T,T2}
+function promote_to(::Type{<:TracedRNumber{T}}, rhs::TracedRArray{T2,0}) where {T,T2}
     return TracedRNumber{T}((), @opcall(convert(TracedRArray{T,0}, rhs)).mlir_data)
 end
 
-function promote_to(::Type{TracedRNumber{T}}, rhs::Number) where {T<:ReactantFloat8}
+function promote_to(::Type{<:TracedRNumber{T}}, rhs::Number) where {T<:ReactantFloat8}
     res = @opcall(fill(rhs))
     return @opcall convert(
         TracedRNumber{T}, TracedRNumber{unwrapped_eltype(res)}((), res.mlir_data)
     )
 end
 
-function promote_to(::Type{TracedRNumber{T}}, rhs::Number) where {T}
+function promote_to(::Type{<:TracedRNumber{T}}, rhs::Number) where {T}
     return promote_to(TracedRNumber{T}, T(rhs))
 end
 
-function promote_to(::Type{TracedRNumber{T}}, rhs::T) where {T<:ReactantPrimitive}
+function promote_to(::Type{<:TracedRNumber{T}}, rhs::T) where {T<:ReactantPrimitive}
     res = @opcall fill(rhs)
     return TracedRNumber{T}((), res.mlir_data)
 end
diff --git a/src/TracedRArray.jl b/src/TracedRArray.jl
index f5625fbc52..0d4144753c 100644
--- a/src/TracedRArray.jl
+++ b/src/TracedRArray.jl
@@ -23,7 +23,7 @@ Base.strides(x::TracedRArray) = Base.size_to_strides(1, size(x)...)
 
 Base.IndexStyle(::Type{<:TracedRArray}) = Base.IndexLinear()
 
-Base.elsize(::Type{TracedRArray{T,N}}) where {T,N} = sizeof(T)
+Base.elsize(::Type{<:TracedRArray{T,N}}) where {T,N} = sizeof(T)
 
 # This is required otherwise we will copy a tracedrarray each time
 # we use it
@@ -289,7 +289,7 @@ function Base.similar(
 end
 
 function Base.similar(
-    ::Broadcasted{AbstractReactantArrayStyle{N}}, ::Type{TracedRNumber{T}}, dims
+    ::Broadcasted{AbstractReactantArrayStyle{N}}, ::Type{<:TracedRNumber{T}}, dims
 ) where {T<:Reactant.ReactantPrimitive,N}
     @assert N isa Int
     return (@opcall fill(zero(T), dims))::TracedRArray{T,N}
diff --git a/src/TracedRNumber.jl b/src/TracedRNumber.jl
index c3a1377390..8289603137 100644
--- a/src/TracedRNumber.jl
+++ b/src/TracedRNumber.jl
@@ -30,12 +30,12 @@ function Base.eps(::Type{TracedRNumber{T}}) where {T}
 end
 Base.eps(x::TracedRNumber{T}) where {T} = eps(typeof(x))
 
-function Base.typemin(::Type{TracedRNumber{T}}) where {T}
+function Base.typemin(::Type{<:TracedRNumber{T}}) where {T}
     return Reactant.promote_to(TracedRNumber{T}, typemin(T))
 end
 Base.typemin(x::TracedRNumber{T}) where {T} = typemin(typeof(x))
 
-function Base.typemax(::Type{TracedRNumber{T}}) where {T}
+function Base.typemax(::Type{<:TracedRNumber{T}}) where {T}
     return Reactant.promote_to(TracedRNumber{T}, typemax(T))
 end
 Base.typemax(x::TracedRNumber{T}) where {T} = typemax(typeof(x))
@@ -1053,17 +1053,17 @@ function Base.copysign(x::S, y::TracedRNumber{T}) where {S<:Number,T}
     return copysign(Reactant.promote_to(TracedRNumber{S}, x), y)
 end
 
-function Base.zeros(::Type{TracedRNumber{T}}, dims::Dims{N}) where {T,N}
+function Base.zeros(::Type{<:TracedRNumber{T}}, dims::Dims{N}) where {T,N}
     return @opcall fill(zero(T), dims)
 end
-function Base.zeros(::Type{TracedRNumber{T}}, ::Tuple{}) where {T}
+function Base.zeros(::Type{<:TracedRNumber{T}}, ::Tuple{}) where {T}
     return @opcall fill(zero(T), ())
 end
 
-function Base.ones(::Type{TracedRNumber{T}}, dims::Dims{N}) where {T,N}
+function Base.ones(::Type{<:TracedRNumber{T}}, dims::Dims{N}) where {T,N}
     return @opcall fill(one(T), dims)
 end
-function Base.ones(::Type{TracedRNumber{T}}, ::Tuple{}) where {T}
+function Base.ones(::Type{<:TracedRNumber{T}}, ::Tuple{}) where {T}
     return @opcall fill(one(T), ())
 end
 
diff --git a/src/TracedRange.jl b/src/TracedRange.jl
index 25ec0a98ac..1e8fa1ed93 100644
--- a/src/TracedRange.jl
+++ b/src/TracedRange.jl
@@ -154,7 +154,7 @@ function Base._in_unit_range(
     return (i > 0) & (val <= v.stop) & (val >= v.start)
 end
 
-@inline function Base.length(r::TracedUnitRange{TracedRNumber{T}}) where {T}
+@inline function Base.length(r::TracedUnitRange{<:TracedRNumber{T}}) where {T}
     if r.length >= 0
         return r.length
     end
diff --git a/src/TracedUtils.jl b/src/TracedUtils.jl
index ee74b8a727..a1bb430e32 100644
--- a/src/TracedUtils.jl
+++ b/src/TracedUtils.jl
@@ -107,7 +107,7 @@ function set_mlir_data!(x::TracedRArray, data)
     return x
 end
 
-function set_mlir_data!(x::Base.ReshapedArray{TracedRNumber{T}}, data) where {T}
+function set_mlir_data!(x::Base.ReshapedArray{<:TracedRNumber{T}}, data) where {T}
     set_mlir_data!(
         parent(x),
         get_mlir_data(@opcall(reshape(TracedRArray{T}(data), size(parent(x))...))),
@@ -116,7 +116,7 @@ function set_mlir_data!(x::Base.ReshapedArray{TracedRNumber{T}}, data) where {T}
 end
 
 function get_ancestor_and_indices(
-    x::Base.ReshapedArray{TracedRNumber{T},N}, indices::Vector{CartesianIndex{N}}
+    x::Base.ReshapedArray{<:TracedRNumber{T},N}, indices::Vector{CartesianIndex{N}}
 ) where {T,N}
     linear_indices = LinearIndices(size(x))[indices]
     parent_linear_indices = LinearIndices(size(parent(x)))[linear_indices]
@@ -124,7 +124,7 @@ function get_ancestor_and_indices(
 end
 
 function get_ancestor_and_indices(
-    x::Base.ReshapedArray{TracedRNumber{T},N}, indices...
+    x::Base.ReshapedArray{<:TracedRNumber{T},N}, indices...
 ) where {T,N}
     @assert length(indices) == N "Expected $N indices, got $(length(indices))"
     indices = Base.to_indices(x, indices)
@@ -160,7 +160,7 @@ function get_ancestor_and_indices(
 end
 
 function set_mlir_data!(
-    x::PermutedDimsArray{TracedRNumber{T},N,perm,iperm}, data
+    x::PermutedDimsArray{<:TracedRNumber{T},N,perm,iperm}, data
 ) where {T,N,perm,iperm}
     set_mlir_data!(parent(x), get_mlir_data(permutedims(TracedRArray{T}(data), iperm)))
     return x
diff --git a/src/stdlibs/LinearAlgebra.jl b/src/stdlibs/LinearAlgebra.jl
index 0bf5a9cd48..1c4b343763 100644
--- a/src/stdlibs/LinearAlgebra.jl
+++ b/src/stdlibs/LinearAlgebra.jl
@@ -81,7 +81,7 @@ include("factorization/Factorization.jl")
 
 # Various Wrapper Arrays defined in LinearAlgebra
 function ReactantCore.materialize_traced_array(
-    x::Transpose{TracedRNumber{T},<:AnyTracedRArray}
+    x::Transpose{<:TracedRNumber{T},<:AnyTracedRArray}
 ) where {T}
     px = materialize_traced_array(parent(x))
     A = ndims(px) == 1 ? reshape(px, :, 1) : px
@@ -89,7 +89,7 @@ function ReactantCore.materialize_traced_array(
 end
 
 function ReactantCore.materialize_traced_array(
-    x::Adjoint{TracedRNumber{T},<:AnyTracedRArray}
+    x::Adjoint{<:TracedRNumber{T},<:AnyTracedRArray}
 ) where {T}
     return @opcall conj(
         materialize_traced_array(transpose(materialize_traced_array(parent(x))))
@@ -97,13 +97,13 @@ function ReactantCore.materialize_traced_array(
 end
 
 function ReactantCore.materialize_traced_array(
-    x::Diagonal{TracedRNumber{T},<:AnyTracedRVector}
+    x::Diagonal{<:TracedRNumber{T},<:AnyTracedRVector}
 ) where {T}
     return diagm(materialize_traced_array(parent(x)))
 end
 
 function ReactantCore.materialize_traced_array(
-    x::Tridiagonal{TracedRNumber{T},<:AnyTracedRVector}
+    x::Tridiagonal{<:TracedRNumber{T},<:AnyTracedRVector}
 ) where {T}
     return diagm(-1 => x.dl, 0 => x.d, 1 => x.du)
 end
@@ -112,7 +112,7 @@ for (AT, comp) in ((:LowerTriangular, "GE"), (:UpperTriangular, "LE"))
     uAT = Symbol(:Unit, AT)
     @eval begin
         function ReactantCore.materialize_traced_array(
-            x::LinearAlgebra.$(AT){TracedRNumber{T},<:AnyTracedRMatrix}
+            x::LinearAlgebra.$(AT){<:TracedRNumber{T},<:AnyTracedRMatrix}
         ) where {T}
             m, n = size(x)
             px = materialize_traced_array(parent(x))
@@ -123,7 +123,7 @@ for (AT, comp) in ((:LowerTriangular, "GE"), (:UpperTriangular, "LE"))
         end
 
         function ReactantCore.materialize_traced_array(
-            x::LinearAlgebra.$(uAT){TracedRNumber{T},<:AnyTracedRMatrix}
+            x::LinearAlgebra.$(uAT){<:TracedRNumber{T},<:AnyTracedRMatrix}
         ) where {T}
             m, n = size(x)
             px = materialize_traced_array(parent(x))
@@ -139,7 +139,7 @@ for (AT, comp) in ((:LowerTriangular, "GE"), (:UpperTriangular, "LE"))
 end
 
 function ReactantCore.materialize_traced_array(
-    x::Hermitian{TracedRNumber{T},<:AnyTracedRMatrix}
+    x::Hermitian{<:TracedRNumber{T},<:AnyTracedRMatrix}
 ) where {T}
     m, n = size(x)
     row_idxs = @opcall iota(Int, [m, n]; iota_dimension=1)
@@ -152,7 +152,7 @@ function ReactantCore.materialize_traced_array(
 end
 
 function ReactantCore.materialize_traced_array(
-    x::Symmetric{TracedRNumber{T},<:AnyTracedRMatrix}
+    x::Symmetric{<:TracedRNumber{T},<:AnyTracedRMatrix}
 ) where {T}
     m, n = size(x)
     row_idxs = @opcall iota(Int, [m, n]; iota_dimension=1)
@@ -165,7 +165,7 @@ function ReactantCore.materialize_traced_array(
 end
 
 function TracedUtils.set_mlir_data!(
-    x::Transpose{TracedRNumber{T},TracedRArray{T,N}}, data
+    x::Transpose{<:TracedRNumber{T},<:TracedRArray{T,N}}, data
 ) where {T,N}
     tdata = TracedRArray{T}(data)
     px = parent(x)
@@ -180,7 +180,7 @@ function TracedUtils.set_mlir_data!(
 end
 
 function TracedUtils.set_mlir_data!(
-    x::Adjoint{TracedRNumber{T},TracedRArray{T,N}}, data
+    x::Adjoint{<:TracedRNumber{T},<:TracedRArray{T,N}}, data
 ) where {T,N}
     tdata = TracedRArray{T}(data)
     px = parent(x)
@@ -194,7 +194,7 @@ function TracedUtils.set_mlir_data!(
 end
 
 function TracedUtils.set_mlir_data!(
-    x::Diagonal{TracedRNumber{T},TracedRArray{T,1}}, data
+    x::Diagonal{<:TracedRNumber{T},<:TracedRArray{T,1}}, data
 ) where {T}
     parent(x).mlir_data = diag(TracedRArray{T}(data)).mlir_data
     return x
@@ -207,7 +207,7 @@ for (AT, dcomp, ocomp) in (
     (:UnitUpperTriangular, "LT", "GE"),
 )
     @eval function TracedUtils.set_mlir_data!(
-        x::LinearAlgebra.$(AT){TracedRNumber{T},<:AnyTracedRMatrix}, data
+        x::LinearAlgebra.$(AT){<:TracedRNumber{T},<:AnyTracedRMatrix}, data
     ) where {T}
         tdata = TracedRArray{T}(data)
         z = zero(tdata)
@@ -228,7 +228,7 @@ for (AT, dcomp, ocomp) in (
 end
 
 function TracedUtils.set_mlir_data!(
-    x::Hermitian{TracedRNumber{T},<:AnyTracedRMatrix}, data
+    x::Hermitian{<:TracedRNumber{T},<:AnyTracedRMatrix}, data
 ) where {T}
     if x.uplo == 'L'
         set_mlir_data!(LowerTriangular(parent(x)), data)
@@ -239,7 +239,7 @@ function TracedUtils.set_mlir_data!(
 end
 
 function TracedUtils.set_mlir_data!(
-    x::Symmetric{TracedRNumber{T},<:AnyTracedRMatrix}, data
+    x::Symmetric{<:TracedRNumber{T},<:AnyTracedRMatrix}, data
 ) where {T}
     if x.uplo == 'L'
         set_mlir_data!(LowerTriangular(parent(x)), data)
@@ -250,7 +250,7 @@ function TracedUtils.set_mlir_data!(
 end
 
 function TracedUtils.set_mlir_data!(
-    x::Tridiagonal{TracedRNumber{T},<:AnyTracedRVector}, data
+    x::Tridiagonal{<:TracedRNumber{T},<:AnyTracedRVector}, data
 ) where {T}
     tdata = TracedRArray{T}(data)
     set_mlir_data!(x.dl, materialize_traced_array(diag(tdata, -1)).mlir_data)
@@ -259,7 +259,7 @@ function TracedUtils.set_mlir_data!(
     return x
 end
 
-Reactant.aos_to_soa(x::Tridiagonal{TracedRNumber{T}}) where {T} = x
+Reactant.aos_to_soa(x::Tridiagonal{<:TracedRNumber{T}}) where {T} = x
 
 # Core functions
 function overloaded_mul(
@@ -622,7 +622,7 @@ tfun_to_char(::typeof(transpose)) = 'T'
 tfun_to_char(::typeof(adjoint)) = 'C'
 
 function LinearAlgebra.generic_trimatdiv!(
-    C::AbstractVecOrMat{TracedRNumber{T}},
+    C::AbstractVecOrMat{<:TracedRNumber{T}},
     uploc,
     isunitc,
     tfun::Function,
@@ -645,7 +645,7 @@ function LinearAlgebra.generic_trimatdiv!(
 end
 
 function LinearAlgebra.generic_trimatdiv!(
-    C::AbstractVecOrMat{TracedRNumber{T}},
+    C::AbstractVecOrMat{<:TracedRNumber{T}},
     uploc,
     isunitc,
     tfun::Function,
@@ -659,7 +659,7 @@ function LinearAlgebra.generic_trimatdiv!(
 end
 
 function LinearAlgebra.generic_mattridiv!(
-    C::AbstractMatrix{TracedRNumber{T}},
+    C::AbstractMatrix{<:TracedRNumber{T}},
     uploc,
     isunitc,
     tfun::Function,
@@ -682,7 +682,7 @@ function LinearAlgebra.generic_mattridiv!(
 end
 
 function LinearAlgebra.generic_mattridiv!(
-    C::AbstractMatrix{TracedRNumber{T}},
+    C::AbstractMatrix{<:TracedRNumber{T}},
     uploc,
     isunitc,
     tfun::Function,
diff --git a/test/integration/linear_algebra.jl b/test/integration/linear_algebra.jl
index c301db6d8e..01286cc820 100644
--- a/test/integration/linear_algebra.jl
+++ b/test/integration/linear_algebra.jl
@@ -546,3 +546,16 @@ diagonal_3_arg_mul(x, y) = y' * Diagonal(x) * y
 
     @test @jit(diagonal_3_arg_mul(x_ra, y_ra)) ≈ diagonal_3_arg_mul(x, y)
 end
+
+@testset "Triangular solve with captured concrete RHS" begin
+    M = collect(reshape(1.0:9.0, 3, 3)) + 10.0 * I
+    b = [1.0, 2.0, 3.0]
+    M_ra = Reactant.to_rarray(M)
+    b_ra = Reactant.to_rarray(b)
+    # `b_ra` is captured (concrete); the solve allocates its output via
+    # `similar(b_ra, <traced eltype>, ...)`, which must yield a traced array
+    # rather than hit `primitive_type` on the wrapped element type.
+    @test Array(@jit((m -> UpperTriangular(m) \ b_ra)(M_ra))) ≈ UpperTriangular(M) \ b
+    @test Array(@jit(((m, v) -> LowerTriangular(m) \ v)(M_ra, b_ra))) ≈
+        LowerTriangular(M) \ b
+end