NSolve[{a^10 E^-a - b^10 E^-b ==
   0, (362880 +
       a (362880 +
          a (181440 +
             a (60480 +
                a (15120 +
                   a (3024 +
                    a (504 +
                    a (72 + a (9 + a))))))))) E^-a + (-362880 -
       b (362880 +
          b (181440 +
             b (60480 +
                b (15120 +
                   b (3024 +
                    b (504 + b (72 + b (9 + b))))))))) E^-b + 0.99 ==
   0}, {a, b}]

{#, NMinimize[(a^10 E^-a -
   b^10 E^-b)^2 + ((362880. +
      a (362880. +
         a (181440. +
            a (60480. +
               a (15120. +
                a (3024. +
                a (504. +
                a (72. + a (9. + a))))))))) E^-a + (-362880. -
      b (362880. +
         b (181440. +
            b (60480. +
               b (15120. +
                b (3024. +
                b (504. + b (72. + b (9. + b))))))))) E^-b +
   0.99)^2, {a, b}, Method -> #]} & /@
{"NelderMead", "DifferentialEvolution", "SimulatedAnnealing", "RandomSearch"}

{{"NelderMead", {0.965138, {a -> 1.96905, b -> 1.96881}}},
 {"DifferentialEvolution", {3.38813*10^-21, {a -> 1.69024, b -> -1.25858}}},
 {"SimulatedAnnealing", {1.11485*10^-20, {a -> 1.69024, b -> -1.25858}}},
 {"RandomSearch", {0.968532, {a -> 0.900447, b -> 0.774213}}}}

f[a_, b_] := a^10 E^-a - b^10 E^-b;
g[a_, b_] := (362880 +
      a (362880 +
         a (181440 +
            a (60480 +
               a (15120 +
                  a (3024 +
                    a (504 +
                    a (72 + a (9 + a))))))))) E^-a + (-362880 -
      b (362880 +
         b (181440 +
            b (60480 +
               b (15120 +
                  b (3024 + b (504 + b (72 + b (9 + b))))))))) E^-b +
   0.99;

f[10, 10]
(* 0 *)

g[10, 9.99997819382]
(* -1.19762*10^-7 *)

DynamicModule[{
   searchRadius = 20,
   searchOverlap = 1,
   searchXmin = -200,
   searchXmax = 600,
   searchYmin = -400,
   searchYmax = 400,
   plotZmin = -1000,
   plotZmax = 1000,
   currentSearchArea = {},
   localMinima = {},
   localMinimaBelowThreshold = {},
   threshold = 10^-6,
   algorithms = {"NelderMead", "DifferentialEvolution",
     "SimulatedAnnealing", "RandomSearch"},
   i, j, imin, imax, jmin, jmax, x, y
   },
  Print@Show[Plot3D[
     {Log[f[x, y]^2], Log[g[x, y]^2]},
     {x, searchXmin, searchXmax},
     {y, searchYmin, searchYmax},
     PlotRange -> {
       {searchXmin - searchRadius - searchOverlap/2,
        searchXmax + searchRadius + searchOverlap/2},
       {searchYmin - searchRadius - searchOverlap/2,
        searchYmax + searchRadius + searchOverlap/2},
       {plotZmin, plotZmax}},
     PlotStyle -> {
       {Opacity[0.5], Blue},
       {Opacity[0.5], Yellow}
       },
     MeshStyle -> Gray,
     ImageSize -> Full
     ],
    Graphics3D[{Red, Opacity[0.7], EdgeForm[None],
      Dynamic[Cuboid[currentSearchArea[[1]],
        currentSearchArea[[2]]]]}],
    Graphics3D[{Red, Dotted,
      Dynamic[Table[
        Line[{{t[[1]], t[[2]], plotZmin}, {t[[1]], t[[2]],
           plotZmax}}], {t, localMinima}]]}],
    Graphics3D[{Green,
      Dynamic[Table[
        Line[{{t[[1]], t[[2]], plotZmin}, {t[[1]], t[[2]],
           plotZmax}}], {t, localMinimaBelowThreshold}]]}]
    ];
  For[i = searchXmin, i <= searchXmax, i += 2*searchRadius,
   For[j = searchYmin, j <= searchYmax, j += 2*searchRadius,
    imin = i - searchRadius - searchOverlap/2;
    imax = i + searchRadius + searchOverlap/2;
    jmin = j - searchRadius - searchOverlap/2;
    jmax = j + searchRadius + searchOverlap/2;
    currentSearchArea = {{imin, jmin, plotZmin}, {imax, jmax,
       plotZmax}};
    Scan[(
       {x, y} = {a, b} /. #;
       If[x != imin && x != imax && y != jmin && y != jmax,
        If[f[x, y]^2 + g[x, y]^2 < threshold,
          Print[{x, y, f[x, y], g[x, y]}];

          localMinimaBelowThreshold =
           Append[localMinimaBelowThreshold, {x, y}],
          localMinima = Append[localMinima, {x, y}]
          ];
        ]) &,
     Quiet@
        NMinimize[{f[a, b]^2 + g[a, b]^2, {imin < a < imax,
            jmin < b < jmax}}, {a, b}, Method -> #][[2]] & /@
      algorithms
     ]
    ]
   ];
  currentSearchArea = {{0, 0, 0}, {0, 0, 0}};
  ];