diff --git a/src/systems/abstractsystem.jl b/src/systems/abstractsystem.jl
index 040977fdb8..3353690b04 100644
--- a/src/systems/abstractsystem.jl
+++ b/src/systems/abstractsystem.jl
@@ -1223,21 +1223,24 @@ end
 struct ObservedFunctionCache{S}
     sys::S
     dict::Dict{Any, Any}
+    steady_state::Bool
     eval_expression::Bool
     eval_module::Module
 end
 
-function ObservedFunctionCache(sys; eval_expression = false, eval_module = @__MODULE__)
-    return ObservedFunctionCache(sys, Dict(), eval_expression, eval_module)
+function ObservedFunctionCache(
+        sys; steady_state = false, eval_expression = false, eval_module = @__MODULE__)
+    return ObservedFunctionCache(sys, Dict(), steady_state, eval_expression, eval_module)
 end
 
 # This is hit because ensemble problems do a deepcopy
 function Base.deepcopy_internal(ofc::ObservedFunctionCache, stackdict::IdDict)
     sys = deepcopy(ofc.sys)
     dict = deepcopy(ofc.dict)
+    steady_state = ofc.steady_state
     eval_expression = ofc.eval_expression
     eval_module = ofc.eval_module
-    newofc = ObservedFunctionCache(sys, dict, eval_expression, eval_module)
+    newofc = ObservedFunctionCache(sys, dict, steady_state, eval_expression, eval_module)
     stackdict[ofc] = newofc
     return newofc
 end
@@ -1248,6 +1251,12 @@ function (ofc::ObservedFunctionCache)(obsvar, args...)
             ofc.sys, obsvar; eval_expression = ofc.eval_expression,
             eval_module = ofc.eval_module)
     end
+    if ofc.steady_state
+        obs = let fn = obs
+            fn1(u, p, t = Inf) = fn(u, p, t)
+            fn1
+        end
+    end
     if args === ()
         return obs
     else
diff --git a/src/systems/diffeqs/abstractodesystem.jl b/src/systems/diffeqs/abstractodesystem.jl
index 74eb4c2809..6c54cf2200 100644
--- a/src/systems/diffeqs/abstractodesystem.jl
+++ b/src/systems/diffeqs/abstractodesystem.jl
@@ -399,29 +399,7 @@ function DiffEqBase.ODEFunction{iip, specialize}(sys::AbstractODESystem,
         ArrayInterface.restructure(u0 .* u0', M)
     end
 
-    obs = observed(sys)
-    observedfun = if steady_state
-        let sys = sys, dict = Dict()
-            function generated_observed(obsvar, args...)
-                obs = get!(dict, value(obsvar)) do
-                    SymbolicIndexingInterface.observed(
-                        sys, obsvar; eval_expression, eval_module)
-                end
-                if args === ()
-                    return let obs = obs
-                        fn1(u, p, t = Inf) = obs(u, p, t)
-                        fn1
-                    end
-                elseif length(args) == 2
-                    return obs(args..., Inf)
-                else
-                    return obs(args...)
-                end
-            end
-        end
-    else
-        ObservedFunctionCache(sys; eval_expression, eval_module)
-    end
+    observedfun = ObservedFunctionCache(sys; steady_state, eval_expression, eval_module)
 
     jac_prototype = if sparse
         uElType = u0 === nothing ? Float64 : eltype(u0)