Skip to content
Solvometry

Early access · Agentic AI optimization

AI-powered optimization. Your models, solved faster.

Most teams pay for a full commercial solver when all they need is the answer, fast. Solvometry is an agentic AI harness for mathematical optimization: send the model you already have and get the answer back. It learns from every run and checks every answer against your model.

  • No model rewrite
  • No commercial solver license
  • Every answer verified
Explore the technology
Problem classes
LP · MILP
Interfaces
Python · REST · MPS
Status
Pre-launch

Why Solvometry

Spend your time on the model, not the machinery.

Optimization teams can lose weeks to installing solvers, tuning parameters and sizing infrastructure, and then start every recurring solve from scratch. Solvometry is built to take that work off their plate: a shorter path from a model to decisions in production, with fewer specialists tied up in solver operations.

Nothing to install or operate

No solver installations, license servers or compute fleet to maintain. One API call from the code you already have.

No tuning expertise required

Solvometry selects the solver and its configuration for each model, so your team works on the formulation, not the parameters.

Better on the problems you solve every day

Designed to learn from your recurring workloads, so each run can start from what earlier runs discovered.

Capacity sized to each solve

Cloud compute matched to the job, from second-long LPs to hour-long MILPs, without provisioning for peak demand.

Solvometry is in development. Early-access partners will help validate these benefits on real workloads.

Why optimization needs to evolve

Solvers got faster. The workflow did not get smarter.

Modern mathematical programming is extraordinarily powerful. But getting good performance out of it still depends on manual choices about which solver to use, how to configure it, and which computational strategy to apply. Those choices are made by people, under deadline, with limited evidence.

No algorithm wins everywhere

Performance variability in MILP is well documented: the best solver, and even the best setting of a single solver, changes from instance to instance. Choosing one engine and one configuration for every workload leaves performance on the table, systematically.

Configuration is expert labor

Hundreds of parameters, presolve choices, emphasis settings, cut strategies and heuristics. Tuning them is slow, specialist work that rarely transfers when the data changes, and it is usually done once and never revisited.

Experience is thrown away

Most organizations solve structurally similar models every day. Yet each run starts from scratch, as if the organization had never solved anything like it before. Everything learned from earlier runs is thrown away.

Which strategy is best? It depends on the instance.Illustrative, not benchmark data

Each column is a problem instance; each row a solving strategy. The highlighted cell marks the fastest strategy for that instance.

fastest for instance slower → much slower
This is the classical algorithm selection problem (Rice, 1976), and it is a prediction problem. Given the features of an instance, which strategy should run? Answering it well requires data from many solves. That is what Solvometry is designed to accumulate.

The compounding advantage

Out of the box is the slowest way to solve the same problem twice.

Every solver, commercial ones included, approaches each run as if it had never seen your problem before. But your problems are not new. You solve them every day, and every one of those runs holds evidence about what works.

Solvometry turns that evidence into a learned execution strategy for your workload, and that is how it can outperform the same solver run out of the box on the problems you run most. In our internal testing, it reached a first usable plan up to 20 times faster than the same solver on its own, and proved plans optimal that the solver alone could not finish within the time limit, with every answer independently verified.*

Same recurring problem, same time limitIllustrative
gaptime →strong solution, earlyfirst solution, out of the boxyour time limit
Solvometry, learned execution Out-of-the-box solver

Not a parameter file. A system that learns your workload.

The advantage does not come from one setting you could copy. It comes from a learning system that observes every run, decides how each new one should be solved, and keeps getting sharper on your problems:

A working model of your workload

Solvometry learns how each of your problem families behaves, and recognizes new instances even as data, sizes and formulations drift.

A strategy chosen for every run

Each solve gets an execution strategy selected from what has actually worked on your problems, across engines, configurations and search techniques.

Gains that compound with use

Every permitted run adds evidence. Improvements build across your workload with no scripts, settings or benchmarks for your team to maintain.

Never trades away correctness

When the evidence is thin, it falls back to proven defaults. Either way, the solver's own bound certifies every answer.

See it on your own problem.

Bring a recurring workload. We will benchmark Solvometry against your current setup, on your instances, under your time limits.

Apply for a benchmark

* Internal testing on recurring workloads, compared with the same solver run without Solvometry. Results vary with the problem, how much the data changes between runs and the time limit.

Sample runs

Tomorrow's plan, near‑optimal while the default is still searching.

A multi-skill staff rota, re-planned every day. On this day, which Solvometry had never seen, it had a rota within 1% of the best in 5.7 seconds. Default solver settings, with the same time limit and hardware, took 53.1 seconds.

faster to a near-optimal rota on the day shown
9x
faster to a near-optimal rota on the day shown
days reaching a rota within 1% sooner
34 of 40
days reaching a rota within 1% sooner
median time to a rota within 1% of the best
6 s vs 28 s
median time to a rota within 1% of the best

Solvometry

5.7 s

to a rota within 1% of the best

Default settings

53.1 s

to a rota within 1% of the best

Default settingsSolvometry
100%10%1%0.1%bestwithin 1%0s30s60s90s120s
Percentage above the best rota found, over the full 2-minute limit (replay sped up), on the strongest of 40 held-out sample days. Solvometry reaches the best rota at 45 seconds; the default settings are still improving when the 2-minute limit ends. Every answer is checked against the original model.

Sample results from internal testing on recurring planning models built from public data: days held out from learning (40 each for the rota and fleet models, 10 for the power schedule, where on 2 further days no method found a schedule within 30 minutes), each compared with default solver settings under the same time limit and hardware. Results vary by problem and day; on some days the default settings were faster.

Explainability agent

Ask why. Get an answer your business understands.

Solvometry's AI explainability agent turns the mathematics behind a plan into plain language: what is holding the plan back, what that costs, and what would change it. The agent explains; it never invents the plan. Every figure it quotes is read from the solved model and checked.

  • Names the resource or rule that limits the plan, in your terms
  • Puts a price on it: what one more unit would be worth
  • Answers follow-up what-if questions by re-solving, not by guessing

Weekly production plan · week 47

Prototype preview
Why did next week's plan drop the Midwest Fabrication bracket order?

Steel is the limit. The plan uses all 1,240 tonnes of cold-rolled coil available next week. Of the eight orders competing for that coil, the Midwest bracket order earns the least per tonne, so it was the one deferred.

Each extra tonne of coil would be worth $118 to next week's plan, for up to 85 more tonnes. Buying 60 tonnes from your secondary supplier, at a $40 per tonne premium, would let the plan fill the order and add about $4,700 in margin.

Limiting resource
Cold-rolled coil, week 47: 1,240 of 1,240 t used
Value of one more tonne
$118, valid for up to 85 more tonnes
Order deferred
Midwest Fabrication, 18-gauge brackets: lowest margin per tonne of coil
What if the coil delivery slips two days?Which orders are most exposed to steel prices?Show me the plan without the Midwest order
Prototype preview with an illustrative example: the company, orders and figures are invented. The explainability agent is in development.

How Solvometry works

Four stages. One feedback loop.

You describe the problem and the time you can spend. Solvometry decides how to solve it, and every permitted run makes the next decision better informed.

01 / SUBMIT

Bring a mathematical model through a familiar interface.

Send a model from Python, over REST, or as a standard MPS or LP file. Keep the modeling framework you already use. Declare only what matters to you: the problem, the time budget, and the outputs you need.

  • No solver selection required
  • No rewrite of existing models
  • Explicit time and resource limits

Python SDK

launch target

REST API

launch target

MPS / LP files

launch target

Pyomo

early integration

PuLP

early integration

JuMP

planned

MathOpt

planned

AMPL-compatible

exploring

solve(model, time_limit=60)

The intelligence engine

Three layers of intelligence. One interface.

Solvometry is designed as a set of complementary capabilities that compound: selection decides how to solve, learning improves those decisions with experience, and acceleration brings learned guidance into the solve itself.

AutoSolve

01

Intelligent solver selection and configuration.

Instance-based algorithm selection: features of the submitted model are mapped to a ranked set of strategies, constrained by your time limit and the outputs you require.

  • Structural feature extractionIn development
  • Portfolio of HiGHS and SCIP strategiesIn development
  • Parameter predictionNext
  • Capability-aware routing (duals, IIS, pools)Next

AutoLearn

02

Experience-driven adaptation across workloads.

Telemetry from permitted solves refines strategy selection globally, specializes it to your recurring model families, and links related instances so that knowledge is reused rather than rediscovered.

  • Model-family identificationNext
  • Performance-based strategy updatesNext
  • Instance similarity and solution reuseRoadmap
  • Online and sequential learningResearch

AutoAccelerate

03

Learned methods inside the search itself.

Research-driven techniques that use what was learned from your history to reach good answers sooner, while the underlying algorithms keep their mathematical guarantees. Early versions are in internal testing today; each technique will be released only when it is validated.

  • Faster first answers on recurring modelsIn development
  • Focus on what matters in your modelRoadmap
  • Deadline-aware compute allocationResearch
  • Deeper solver integrationResearch

Where Solvometry fits

Not another solver. Not another modeling language.

Traditional solvers provide powerful algorithms. Modeling frameworks help you express problems. Neither decides, from evidence, which algorithm and configuration a particular instance should get. Solvometry is the missing layer between them: an execution engine that combines the strengths of different algorithms and improves with experience.

The initial portfolio is built on proven open-source engines. Over time, we intend to develop proprietary solving and acceleration methods of our own, behind the same interface.

Modeling frameworks

Pyomo · JuMP · PuLP · MathOpt · AMPL

Help you express the mathematical problem and communicate it to a solver.

Solvometry

Intelligent execution layer

Decides how each model should be solved, runs it, verifies the result, and learns from the outcome across your workloads.

Solving engines

HiGHS · SCIP · your commercial solver · future proprietary methods

Provide the rigorous algorithms (simplex, interior point, branch-and-cut) that compute solutions and bounds.

Conceptual demonstration

Watch the engine reason about a model.

Pick a problem family and step through how Solvometry is designed to analyze a model, weigh candidate strategies, and return a result. Everything here is illustrative: no solver runs in your browser and no values are measurements.

Concept demo · not a benchmark

Tip: click any step above the panel to look closer at your own pace.

Model

plant_allocation_2026-10-31.mps

min Σ cost·x + Σ setup·y
s.t. capacity, demand, x ≤ M·y, y ∈ {0,1}

Structural features

variables
12,800 · 65% integer
structure
block-angular by plant
coefficient range
1e-1 … 1e+3
history
recurring daily family
related runs
30 days of history

Candidate strategies

  • Default branch-and-cut

    Safe baseline for any MILP.

  • Presolve-aggressive + cuts

    Big-M setup links benefit from tightening.

  • Learned strategy for this family

    Built from what worked on this family's recent runs.

Result

Press “Run the concept” to see the engine's decision.

Built for developers

One call. No solver flags.

Describe the problem and the time you can afford. The public interface stays small and stable while the intelligence behind it keeps improving.

Result fields

  • status

    optimal, feasible, infeasible, unbounded, time_limit

    Core
  • objective · values

    Objective value and primal variable assignments

    Core
  • best_bound · mip_gap

    Certified dual bound and relative gap for MILP

    Core
  • run

    Strategy, solver, version, parameters, seed for reproducibility

    Core
  • duals · reduced_costs · slacks

    LP sensitivity data; MILP only via fixed-integer LP

    Planned
  • iis

    Irreducible infeasible subsystem for infeasible models

    Planned
  • basis · mip_start · solution_pool

    Warm-start inputs and alternative solutions where supported

    Later

Capabilities differ by problem class and engine. Requests are routed to strategies that support the outputs you ask for, and the response states exactly which engine produced them.

solve.pyAPI preview · SDK in development
from solvometry import solve

# Pass a Pyomo or PuLP model, an MPS/LP file, or an SDK-built model.
result = solve("production.mps", time_limit=60)

print(result.status)       # Status.OPTIMAL
print(result.objective)    # 1284310.55
print(result.mip_gap)      # 0.0
print(result.values["x[plant_3,sku_17]"])

The interface shown is a design preview and may change before release. Early-access members will help shape it.

One engine. Many optimization problems.

Domain-independent by design. Specialized by experience.

Solvometry works at the level of mathematics: variables, constraints and objective. It needs no domain template, yet it learns the recurring structure of your models, which is where most practical performance lives.

Supply chain planning

Multi-echelon flows, sourcing and allocation across facilities and periods.

multi-period MILP

Inventory optimization

Lot sizing, replenishment and safety-stock positioning under capacity limits.

lot-sizing MILP

Production scheduling

Sequencing, batching and machine assignment with setups and due dates.

time-indexed MILP

Logistics & transportation

Load planning, fleet assignment and routing on time-expanded networks.

network flow + MILP

Workforce scheduling

Rostering and shift design subject to coverage, labor rules and fairness.

set covering

Resource allocation

Budgets, capacity and assets assigned under competing constraints.

LP / assignment

Energy optimization

Unit commitment, dispatch and storage scheduling across horizons.

unit-commitment MILP

Network design

Facility location and capacity expansion with fixed-charge decisions.

fixed-charge MILP

Financial optimization

Portfolio construction with cardinality, lot and turnover constraints.

mixed-integer LP

General mathematical programming

Any linear or mixed-integer linear model you can write down.

LP · MILP

Mathematical rigor meets machine learning

Learning decides how to solve. Mathematical optimization validates the result.

Machine learning in Solvometry is used to make computational decisions, not to replace the mathematics. A learned model can change how fast a good answer is found. It cannot change whether an answer is feasible or what the certified bound is.

Learning proposes

Statistical models trained on solve telemetry

How to solve each model
chosen from what has worked on your own past runs
Where to begin
informed by what has worked before
Where effort goes
focused on the parts of each model that matter
How to spend the budget
matched to your deadline

Optimization verifies

Exact algorithms with mathematical guarantees

Feasibility
every returned solution is checked against the submitted constraints and bounds
Bounds and gaps
optimality claims come from the solver's dual bound, never from a model's prediction
Status semantics
optimal, feasible, infeasible and time-limit outcomes are reported exactly
Reproducibility
solver, version, parameters and seed are recorded for every run

The asymmetry that makes this safe

A poor prediction costs time, not correctness. If a learned guess is wrong, the solver simply works past it. If a predicted configuration underperforms, the run still terminates with an exact status and a valid bound.

Not a language model guessing answers

Solvometry does not ask an LLM to read your model and produce a solution. Its learning components are predictive models over numerical and structural features of mathematical programs, evaluated by measured solver outcomes.

A decision problem in its own right

Choosing what to run, for how long, and when to switch strategies under a fixed budget is a sequential decision problem. Treating it that way, rather than with static rules, is the research core of the platform.

Product roadmap

Ambitious in direction. Honest about sequence.

Each phase builds on the data and infrastructure of the previous one. Nothing below is generally available today; we will mark capabilities as released only when they are.

  1. IIn development

    Foundation

    Cloud mathematical programming with a consistent API.

    • LP and MILP solving in the cloud
    • Python SDK, REST API, MPS/LP input
    • Time limits and resource controls
    • Reproducible run manifests
    • Core result fields: status, objective, values, bound, gap
  2. IINext

    Intelligence

    Automated algorithm selection and performance-based learning.

    • AI explainability agent: plain-language answers on any plan
    • Feature-based solver and configuration selection
    • Model-family identification
    • Opt-in workload-specific learning
    • LP duals, reduced costs, slacks, IIS
    • Modeling-framework integrations
  3. IIIRoadmap

    Acceleration

    Faster, better answers on the models you run every day.

    • Faster first answers from your solve history
    • Focus on the parts of each model that matter
    • Strategies chosen per model family
    • Private and dedicated deployments
  4. IVResearch

    Research frontier

    Dynamic orchestration and new algorithmic capabilities.

    • Strategy changes during a solve, within your budget
    • Smarter use of compute under a deadline
    • Proprietary solving and acceleration methods
    • Selected expansion beyond linear models

Early access & design partners

Help shape the engine before it ships.

Solvometry is in early development. We are looking for practitioners and organizations with real optimization workloads, especially recurring ones, to evaluate the technology with us and tell us where it matters most.

Waitlist

Join early access

One field. We will notify you as access opens, in the order people joined.

We use your email only to contact you about Solvometry. See our privacy policy.

Design partner program

Build it with us

A small number of teams will work closely with us through the Foundation and Intelligence phases.

What partners get

  • Hands-on access to the engine ahead of public availability
  • Direct working sessions with the founding technical team
  • Influence over the API, integrations and roadmap priorities
  • A benchmark of Solvometry against your current setup, on your own instances

An ideal fit

  • You solve LP or MILP models on a recurring schedule
  • Solve time, tuning effort or solver cost is a real constraint
  • You can share representative (or anonymized) instances under NDA
Start the application below ↓

Design-partner application

Tell us about your optimization workloads

About three minutes. Everything beyond your name, work email and company is optional, but the more we know about how and how often you solve, the better we can judge where Solvometry can help first.

  1. Step 1

  2. Step 2

  3. Step 3

Only name, work email and company are required. See our privacy policy.

FAQ

Precise answers to fair questions.

If your question is not here, email us. Technical questions are especially welcome.

What is Solvometry?

Solvometry is a cloud mathematical optimization engine under development. You submit an optimization model and a time budget through one API; Solvometry analyzes the model's structure, selects and configures a solving strategy, runs it, verifies the result, and uses permitted solve history to make better strategy decisions over time.

What types of optimization problems will it support?

The initial focus is linear programming (LP) and mixed-integer linear programming (MILP), which cover the large majority of industrial planning, scheduling, allocation and network problems. We intend to expand to other problem classes only once we can support them with the same rigor; we do not claim nonlinear or stochastic optimization support for the first release.

Is Solvometry a mathematical solver or a solver orchestration platform?

Today it is best described as an intelligent execution layer: it decides how each model should be solved and orchestrates proven engines to do it. That is a starting point, not the ceiling. Our long-term plan includes proprietary solving and acceleration methods, delivered behind the same interface so that customers benefit without changing their code.

Does Solvometry replace Gurobi or other solvers?

No. Solvometry is a layer above the solver, not a replacement for it. It decides how each model should be solved, runs it, verifies the result against your model and learns from the outcome. It runs on open-source engines with no license required, and it is designed to use commercial solvers such as Gurobi where you already hold a license. Either way, the gains come from learning your recurring workloads, and every answer is checked before it is returned.

Can I use my own Gurobi or other commercial solver license?

That is the intent. Solvometry works without any commercial license, and it is designed to use a commercial solver you already license so that your existing investment benefits from the same learning and verification. How a license can be used, in our cloud or in your own environment, depends on each vendor's terms; we will confirm the options with design partners before launch.

How does the AI work?

Solvometry computes numerical and structural features of each model (size, integrality, sparsity, coefficient ranges, recognizable constraint structure) and uses statistical and machine-learning models trained on solve outcomes to predict which strategies are likely to perform well. Later phases apply learning inside the search itself. Throughout, exact optimization algorithms compute the solutions and bounds.

Does it use large language models to solve optimization problems?

No. Solvometry does not ask a language model to read a model and produce an answer. The learning components are predictive models over mathematical features, and every reported solution, bound and status comes from a rigorous optimization algorithm and is verified against the submitted model.

How does it learn from previous optimization models?

At three levels. Globally, it learns general relationships between problem structure and strategy performance. At the model-family level, it specializes to your recurring formulations, such as a daily production plan. At the instance level, it exploits similarity between closely related runs, so what one run discovers is not rediscovered by the next. Learning will not improve every individual solve; the gains concentrate on the problems you run repeatedly. We will publish benchmark methodology and results with launch.

Will my mathematical models remain private?

Yes. Your models, data and solutions belong to you and are never shared with other organizations. Family- and instance-level learning stays within your organization's boundary. Any cross-customer learning is designed to use only aggregate, non-identifying structural statistics and solver-performance signals, and we intend to let customers opt out of it entirely. Detailed data-handling terms will be agreed in writing before any design partner shares a model.

Can I use my existing modeling framework?

That is a core design goal. The first release targets a Python SDK, a REST API, and standard MPS and LP files, which most frameworks can already export. Native integrations with Pyomo and PuLP are planned early, with JuMP, MathOpt and AMPL-compatible workflows to follow. Tell us what you use in the design-partner application; it directly affects priority.

What outputs and diagnostics will be available?

Core results include status, objective value, primal values, best bound and MIP gap, plus a run manifest (strategy, solver, version, parameters, seed) for reproducibility. Planned additions include LP dual values, reduced costs, slacks, infeasibility analysis (IIS), basis information, MIP starts and solution pools where supported. Capabilities depend on the problem class: for example, LP shadow prices are not presented as generally valid MILP constraint duals.

Is Solvometry available today?

Not yet. Solvometry is pre-launch and under active development. The API shown on this site is a design preview. Joining the waitlist is the best way to hear when access opens, and design partners will get hands-on access first.

How can I participate in the early-access program?

Join the waitlist with your email for launch updates, or apply to be a design partner if you have real, ideally recurring, LP or MILP workloads. Design partners work directly with the founding team, gain early access, and influence the roadmap. Applying takes about three minutes and carries no obligation.

Every solve should make the next one smarter.

We are building that engine now. Join early, and help decide what it learns first.