This sort of post hoc reasoning behind a decision made by a group of developer is a little dangerous. I think a better phrasing of the question might be, What are the advantages of NDSolveValue over NDSolve, given that NDSolveValue returns only one of the solutions computed by NDSolve? Encouraged by @Szabolcs and by the upvotes on my oversimplified comment, here goes....

Instead of focusing on the issue of the lost solution, one should rather think of the advantages of having some syntactic sugar equivalent to expr /. First@NDSolve[..]. A couple favorites:

This sort of post hoc reasoning behind a decision made by a group of developers is a little dangerous. I think a better phrasing of the question might be, What are the advantages of NDSolveValue over NDSolve, given that NDSolveValue returns only one of the solutions computed by NDSolve? Encouraged by @Szabolcs and by the upvotes on my oversimplified comment, here goes....

Instead of focusing on the issue of the lost solutions, one should rather think of the advantages of having some syntactic sugar equivalent to expr /. First@NDSolve[..]. A couple favorites:

This sort of post hoc reasoning behind a decision made by a group of developer were thinking is a little dangerous. I think a better phrasing of the question might be, *What are the advantages of NDSolveValue over NDSolve, given that NDSolveValue returns only one of the solutions computed by NDSolve? Encouraged by @Szabolcs and by the upvotes on my oversimplified comment, here goes....

I think the primary use of NDSolveValue (singular, not the plural NDSolveValues) is to return a single function ifn (or function expression ifn[x]) that can be evaluated on values of the independent variable(s). @Carl Woll has already discussed some aspects of the convenience of this, but I would add that this use probably occurs many more times in practice than all other uses put together, because so many useful ODEs are of the form $y^{(n)} = F\big(x,y,y',\dots,y^{(n-1)}\big)$, usually just $y'=F(x,y)$ or $y''=F(x,y,y')$. NDSolve will return a single solution to a valid IVP for such an ODE, and NDSolveValue therefore will also return the only solution.

vnds = Values@ NDSolve[{x'[t]^2 == x[t]^2, x[0] == 1}, {x}, {t, 0, 1}];
ndsv = NDSolveValue[{x'[t]^2 == x[t]^2, x[0] == 1}, {x}, {t, 0, 1}];
First[vnds] === ndsv
(*  True  *)

ndsv = NDSolveValue[{x'[t]^2 == x[t]^2, x[0] == 1}, x, {t, 0, 1}];
First[vnds] === ndsv
First@First[vnds] === ndsv
(*
  False
  True
*)

Those are aside from the highly useful InterpolatingFunction returned by NDSolveValue[ivp, x, {t, 0, 1}]. I think almost everyone who uses ODEs a lot, hates always having to remember to type First in x[t] /. First[sol].

I don't know much about Internal`ProcessEquations`FindDependentVariables, so it might not work in all cases. Alternative, for non-PDE systems, one might use the following, which uses documented functions:

If there's a way to get the time-integration interval {a, b} from state, it does not seem to be documented. If someone finds or knows it, then this could probably be extended to PDEs with ease.

This sort of post hoc reasoning behind a decision made by a group of developer is a little dangerous. I think a better phrasing of the question might be, What are the advantages of NDSolveValue over NDSolve, given that NDSolveValue returns only one of the solutions computed by NDSolve? Encouraged by @Szabolcs and by the upvotes on my oversimplified comment, here goes....

I think the primary use of NDSolveValue (singular, not plural NDSolveValues) is to return a single function ifn (or function expression ifn[x]) that can be evaluated on values of the independent variable(s). @Carl Woll has already discussed some aspects of the convenience of this, but I would add that this use probably occurs many more times in practice than all other uses put together, because so many useful ODEs are of the form $y^{(n)} = F\big(x,y,y',\dots,y^{(n-1)}\big)$, usually just $y'=F(x,y)$ or $y''=F(x,y,y')$. NDSolve will return a single solution to a valid IVP for such an ODE, and NDSolveValue therefore will also return the only solution.

vnds = Values@ NDSolve[{x'[t]^2 == x[t]^2, x[0] == 1}, {x}, {t, 0, 1}];
ndsv = NDSolveValue[{x'[t]^2 == x[t]^2, x[0] == 1}, {x}, {t, 0, 1}];
First[vnds] === ndsv
(*  True  *)

vnds = Values@ NDSolve[{x'[t]^2 == x[t]^2, x[0] == 1}, x, {t, 0, 1}];
ndsv = NDSolveValue[{x'[t]^2 == x[t]^2, x[0] == 1}, x, {t, 0, 1}];
First[vnds] === ndsv
First@First[vnds] === ndsv
(*
  False
  True
*)

Those are aside from the highly useful InterpolatingFunction returned by NDSolveValue[ivp, x, {t, 0, 1}]. I think almost everyone who uses ODEs a lot hates always having to remember to type First in x[t] /. First[sol].

I don't know much about Internal`ProcessEquations`FindDependentVariables, so it might not work in all cases. Alternatively, for non-PDE systems, one might use the following, which uses documented functions:

If there's a way to get the time-integration interval {a, b} from state, it does not seem to be documented. If someone finds or knows it, then this could probably be extended to PDEs with ease. The data is inside state.