From decision exploration to certification and explanation
Agent toolkit for AI-guided optimization: evolve from a black-box solution to a defensible decision.
Most consequential decisions never reach an optimizer. They get made in spreadsheets and gut calls because optimization is unapproachable: hard to set up, and when a solver does return an answer, it’s a black-box conclusion nobody trusts or can explain to the room. The hard part isn’t solving the model: it’s trusting the answer, proving it’s right, and explaining why.
I’ve made the case that AI can make optimization accessible, and, relatedly, that a convergent substrate enables an agent to reason through hard, constrained decisions. Now to close the loop where it matters most: from exploring a decision to proving and explaining it.
I built Frontier to help: it provides skills and tools – in a coding agent or an interactive web UI – for framing a decision, exploring trade-offs, certifying selected targets against the stated model, and explaining what would move the answer. Underneath, it pairs an approximate explorer with an exact solver.
You describe your problem in plain language – say, which projects to fund or how to balance a portfolio – the trade-offs come back mapped. Where the exact math applies, the ones you’d commit to come back proven: optimal for their target, with clear levers and margins for changes. What you carry forward is legible: the numbers, the assumptions, and the interpretation kept separate, each judged on its own terms.
One distinction to hold onto: certification proves a choice is optimal for the model as stated. Whether the model matches reality – the right objectives, honest scores, the scenarios that actually matter – is validation, and that stays your real-world judgment, not the solver’s. Frontier sharpens the first so you can spend your attention on the second.
Frontier’s approach
Real decisions are multi-objective and multi-scenario: they require weighing different alternatives that genuinely conflict, across several futures that might play out. The right object is a layered frontier of defensible trade-offs to navigate. That is why exploration is the foundation: map the frontier first, then prove and explain the parts you’ll commit to.
Here’s how Frontier enables the workflow: explore, certify, explain – the agent runs each and reads it back for you. The mechanics below serve that loop.
Explore: map the frontier, broadly and fast. You describe the decision in business language, the translation layer frames the model, and an approximate frontier comes back. Its measure is coverage: how much of the trade-off space you hold.
Certify: prove the points you’d commit to optimal for their own trade-off target, given the model as stated. Curation narrows the frontier to candidates; the exact pass grounds exactly those. Its measure is the optimality gap: how far from proven-best.
Explain: name what would change the answer: why this mix over the alternatives, what holds when the world shifts, and where the most leverage points, in the language of the decision.
The value is less the single optimal number at the end than the iterative exploration, curation, and refinement that gets you there.
Two decisions through the loop
I’ll run two example decisions through the loop. The first is discrete – which projects to fund, pick k of n – where the combinatorial space explodes and certification has the most to prove. The second is continuous – an allocation portfolio, how much to put where – which adds robustness and sensitivity reads.
Which projects should we fund?
A discrete capital decision: pick which projects to fund from many candidates, balancing value, cost, risk, and strategic fit. It has the characteristics that make exploration worth the trouble: a large combinatorial solution space, conflicting objectives, and hard constraints.
You describe the decision and hand over the data (a row per candidate project, with columns for value, cost, risk, and strategic fit); the agent maps it to objectives, options, and hard constraints, and flags what’s missing before anything runs. This is the accessibility promise: the translation layer doing the upstream work that stalls most optimization attempts.
The explorer returns a frontier of non-dominated plans – none can improve one objective without giving up another. Parallel coordinates show how the objectives conflict: one run returns the whole trade-off space.
The agent then narrates the trade-offs in natural language.
Curation is where your judgment comes in: narrowing a hundred-plus plans to a handful you’d defend. You curate directly, and the toolkit tracks those picks across re-runs so a change of assumption tells you which survived.
You’ve explored a broad but unproven frontier; now one exact pass grounds it. A multi-objective decision has many optima, each best in its lane – and each point of interest gets proven for its own. Where a plan you thought was efficient is strictly beaten, you’ve caught heuristic slack before committing.
The recommendation summary states the chosen plan, what it trades off, what’s binding, and what would move it – every claim tracing back to the problem definition and data. A stakeholder can argue with it line by line.
How much should we allocate, and what holds when the world shifts?
A continuous allocation decision: how much to put where rather than which to pick – a mean-variance portfolio across funds (balancing return against risk). The same loop runs, but the continuous shape unlocks two reads the discrete case couldn’t show: robustness across futures, and a sensitivity read from the exact solve.
Because the decision is multi-scenario, you run it across futures – recession, inflation, rate cuts – and watch the achievable set shift: some plans hold up everywhere, others only flatter the base case, and the robust spine is what survives every future. Breadth across objectives and scenarios, in one pass.
The approximate plans trace a risk-return frontier that’s plausible but unproven. The exact overlay settles which of them actually hold up.
Which lever moves the answer? The proof settles what's optimal; what moves it has two reads, and they carry different weight.
Scenarios are the read you lean on: re-solve under a different future and watch which picks survive. Each scenario is a true re-optimization, not a perturbation of the base case. This plan holds in every future.
Sensitivity is the directional lens that supports it: on the continuous allocation (a QP), the exact solve’s duals (the marginal value of relaxing a constraint) point toward your highest-leverage move and your closest call. Real industrial problems are usually degenerate, with overlapping, conflicting constraints binding at once, so the duals give a direction: which lever to look at first, with a cheap re-solve to price the move.
This is also why the continuous case leans on robustness and sensitivity: optimizing hard on estimates tends to favor whatever the noise happened to flatter. The certificate proves the point is optimal for the numbers you fed it; the scenario and sensitivity reads keep that over-fit from going unchallenged.
How the approximate + exact pairing works
Those two decisions ran on a single engine the agent drives under the hood: approximate exploration paired with exact certification.
None of the pieces are new on their own. Mapping a whole frontier and then having the decision-maker choose from it is a-posteriori MCDM; the cognitive load of curating a large frontier is exactly what interactive methods (NIMBUS, NAUTILUS, reference-point approaches) and knee-point selection were built to handle.
What’s new here is the combination baked into a toolkit: an AI agent as the translation layer that frames the decision, an automated gate that certifies only the shapes it can prove as stated, and per-target certification wired into one guided, scenario-aware loop. Exploration is the mapping; certification proves the route you pick.
Why lead with the explorer instead of solving exactly from the start?
Objectives: an exact solver returns one optimum at a time, so tracing a whole frontier means re-solving across a grid that explodes as objectives multiply, while the explorer approximates the whole frontier in one run.
Shape: the fast exact methods need linear or convex structure to bound tightly, and decline a non-convex objective outright rather than guess, while the explorer asks only for a score per candidate and runs on any shape.
Timing (most important): early on, the model is still moving – constraints shifting, objectives added and dropped – so the explorer’s light demands let it keep up, while certifying too early just proves optimality of a model you’re about to change. Once the framing settles, the exact pass takes over and certifies the candidates you’d commit to.
Together they make one frontier you navigate broadly and certify selectively. The explorer – the evolutionary search, guided by the agent that frames and narrates it – maps an approximate frontier on any problem: any shape, any number of objectives, across scenarios. The exact solver certifies the ones that fit it: it proves the points you keep, sharpens the corners, and draws the levers.
The certificate covers the solve step and four things inside it: feasibility, the optimality gap on a supported target problem shape, dominance correction among the points actually evaluated, and the duals where the structure provides them. What surrounds that step stays a matter of judgment: the formulation the agent translated upstream (which carries no per-instance guarantee), the completeness of the heuristic frontier, the scenario assumptions, and the narration downstream.
Ensuring reach
Fast exact methods need a provable shape: linear for the MILP, convex-quadratic for the QP. Real objectives routinely fall outside it: a worst-case minimum over a variable-size selection ("no weak link," averaged across what you pick), a non-convex interaction, or a score that’s just the output of a model. A specialist can sometimes reformulate these back into a provable shape, but each is a bespoke model change, and a black-box score never fits.
Frontier’s gate draws a stricter, automated line: the shapes it can formulate and certify as you stated them. The split is structural: the approximate explorer (NSGA-II/III) fits all seven of Frontier’s problem shapes, while the exact solver (HiGHS or cuOpt) certifies only the three with linear or convex structure.
Measuring performance
Does the pairing pay off in practice? I benchmarked three shapes at scale – a mean-variance QP, a production-mix LP, and a binary capital MILP – comparing the explorer alone, a full exact pass over every candidate, and progressive certify (explore, then certify only the keepers). The full exact pass is the everyday baseline; specialist exact-frontier methods (AUGMECON2, Benson, critical-line) trace the front more cleverly. On GPU, the exact pass with cuOpt also shows promising acceleration on large, dense QP and complex LP.
Certification is what makes the frontier trustworthy. The explorer maps the frontier broadly, by design, so a meaningful share of its “efficient” points are actually dominated, more so as the problem grows combinatorially. Certifying proves which points are genuinely efficient, so on the hard cases the proof is what you navigate by. Because progressive certify proves only the curated keepers, it keeps the explorer’s breadth and stays far cheaper than a full exact pass, which burns its budget solving every point and narrows; the gap widens with scale. (Coverage is relative to the method’s own exact overlay; how much of the true front it captures is unknown.)
Conclusion
A heuristic explores – fast and broad – mapping the frontier of trade-offs, and an exact solver is its follow-on, proving that the options you’d actually commit to are the real best, not just the best the search happened to find.
Coverage and certification close the exploration gap, where dominated options looked like reasonable recommendations. The sensitivity read closes the interpretability gap, answering in decision terms what the agent could only narrate before: which lever to pull first, and which calls sit closest to flipping. And the iteration gap closes operationally: curated picks survive re-solves, and each scenario is a true re-optimization rather than a fresh start.
We use AI to make optimization accessible, while optimization makes AI’s guidance rigorous. The math underneath is standard and checkable: every kept point is checked head-to-head against an exact overlay of the selected targets – a well-understood pairing of heuristic search and exact proof.
That is what you take into the room: the trade-offs the search surfaced, the candidates certified wherever the math allows, and a clear read on which claims carry a proof and which carry your judgment. Every claim shows what it’s based on.
Frontier is open source as an agent toolkit with guided web UI at github.com/cafzal/frontier. Try it out and share feedback. If you’re wrestling with a constrained, multi-objective decision and want to try a new approach – or building at the intersection of agents and optimization and want to compare notes – reach out.