the way AI agents work on data reliably: certified solves for complex datasets, with the proof attached.
from quadratic and cutting plane. classical and exact, available on AWS Marketplace. no annealer posing as a proof, no sampler, no probability of being right.
put it to the testassay · qplib instance 2036
binary non-convex quadratic program
The QPLIB maintainer independently verified the improved objective value and is updating the published figure. The instance is a minimisation, so the improvement is 160.
the problem
the problem
optimization, filtering, and inference still run on code that was written once, never gated, and trusted anyway.
An agent reaches for numpy inside a tool call. A team ships a solver wrapper nobody re-checked after the refactor. The number comes back, and it looks exactly like a correct number would.
That is the whole problem. Nothing visibly separates an answer that was proven from an answer that was merely produced. Both are digits on a screen. The gap between them is not paid for at the moment of computation. It is paid later, by whoever trusted it.
The distinction quplane draws: it is a certifiable agent harness for computation. It does not hand-roll numpy on your data. It routes the data through gated solvers and gets certificates of its answers.
the system
the system
a certifiable agent harness for computation: your input is gated against a reference implementation, routed to the solvers that fit it, and handed back with the evidence still attached.
stage
input / fingerprintData is stored, screened for non-finite values, and given a content hash before anything reads it.
gate
oracle / build-to-failEvery solver is checked against a reference implementation. The gate has to fail before it is allowed to pass.
solve
cpu / anvilOne name routes to a tight CPU build or the GPU tier without changing the call.
contract
status / certificateResults carry a typed block: status, diagnostics, certificates, and warnings beside the native output.
record
provenance / replayInputs are tied to outputs by fingerprint, so any figure traces back to the data that produced it.
how it works
subscribe on AWS, then hand it a question
subscribe on AWS Marketplace
Subscribe with the AWS account you already have. Billing runs through Amazon, so procurement never meets a new vendor and the charge lands on the bill you already pay.
hand it a file and a question
A spreadsheet or CSV, messy as it comes, and a question in plain words. The engine profiles, cleans, and organizes the data before anything runs.
solvers chain and check each other
The question routes across 97 gated solvers. Independent solvers verify the primary answer, detectors re-baseline the forecasters, and a gate weighs the evidence.
a verdict, not just a number
You get the answer, the evidence, and its contract. When the evidence is thin the verdict reads PAPER_ONLY instead of pretending, and when the engine cannot answer accurately it says so plainly.
Prefer the library directly? The CLI and pipeline interface are in the documentation.
The shift is from numerics you wrote to numerics you can point at. Ninety-seven solvers, each shipped with a reference implementation and a gate it has to clear. No timing figure is published until its gate is green.
a different surface
a different surface
What changes when the gate lives inside the library instead of inside your review process.
the gate is not optional
A solver that cannot clear its reference oracle is not callable. There is no flag to skip it.
the result states its own status
Exact, tolerance-bounded, or heuristic. The contract says which, so a heuristic never quietly reads as a proof.
the input is fingerprinted
Content hashes tie a specific answer to the specific bytes it came from, months later.
the tiers are interchangeable
CPU and GPU builds sit behind one name and clear the same gate, so promotion is not a rewrite.
the claim is bounded
Speed is reported in absolute nanoseconds per operation, not as a multiplier over an interpreter.
with quplane: you work from certificates, not confidence.
for agents
the trust layer agents are missing
An agent's number looks the same whether it was proven or invented. Instead of hand-rolling numpy inside a tool call, the agent hands the data here: it gets routed, solved, and returned with a certificate it can show its principal.
self-describing instance
Every instance serves its own instructions: /llms.txt,
/agents.md, and /openapi.json. Point an agent at the
address and it learns the API, the auth, and the rules with no human in the
loop.
a contract on every result
Each answer returns a typed contract: status, certificates, warnings. The input is fingerprinted on every run, so any figure traces back to the exact data that produced it. A proof-bearing status appears only when its verifier accepts the named certificate.
verdicts that gate action
ACT means the instruments agreed. PAPER_ONLY tells
the agent, in its own instructions, not to act on the number and to say so. The
discipline ships with the engine, so any agent that reads the docs inherits
it.
This is the same gate discipline the suite applies to itself, pointed at the biggest producer of unchecked numbers there is: an agent reaching for a solver inside a tool call. A subscription is an engine in your account that your agents can be trusted to use.
results
measured against the public record
On Hans Mittelmann's published Nonconvex QUBO-QPLIB benchmark of 20 August 2026, Quplane holds first place: fastest shifted geometric mean of the field, 22 of 23 instances solved globally against the former leader's 16, and six instances no other listed solver cracks within the hour (3642 in 214s, 3650 in 92s, 3693 in 747s, 3822 in 51s, 3838 in 25s, 3850 in 1358s).
QPLIB itself is a public library of hard quadratic programs, with best-known solutions maintained at ZIB. The three instances below belong to Mittelmann's separate, older Binary Non-Convex QPLIB benchmark; they are absent from that seven-solver table.
See the proof page: planted answers, real solves, contracts attached.
instance 2036
−30820 against a published −30660. Verified by the maintainer, who is updating the listed value.
2017 · 2029 · 2036
Absent from the published table, meaning all seven solvers fail inside the hour. Reached in 58.3s, 57.0s, and 96.8s.
instance 2022
79.3s against BARON at 1412s, with five of the seven timing out entirely.
The 22-of-23 table above is the independent result: Mittelmann ran every listed code on the same 12-core Ryzen 9 5900X, with 12 threads and a one-hour limit, and counts global solves. The separate 2017, 2022, 2029, and 2036 figures shown below came from a 40-core Xeon Gold 5218R and are not part of that ranking. Their hardware and proof claims remain scoped to their own evidence records.
more from the proving groundyour problems run in your AWS account and never leave it.
quplane holds no customer data. storage, access, and billing stay with Amazon.
pricing
pricing
Metered through AWS Marketplace: subscribe with the account you already have and the charge lands on the AWS bill you already pay. Published here because a price you have to ask for is part of the problem. Solvers of this grade normally begin with a sales contact and end with a license agreement; this one begins with a subscribe button and ends with an hourly line item.
engine hours
$2.50 to $8.00 /hour
- the full 97-solver suite and the auto-analyst
- tiered by instance size, from t3.medium at $2.50 to c6i.4xlarge at $8.00
- billed by AWS alongside the EC2 instance it runs on
- typed result contracts distinguish verified, feasible, timed-out, rejected, and failed work
annual contract
$30,000 /year
- unmetered use across your account
- arranged as an AWS Marketplace private offer, so billing still stays with Amazon
- reach us at contact@quplane.com to set one up
subscribe on AWS
bring a problem you already know the answer to.
The fastest way to evaluate a gated solver is to hand it something you have already proven by other means, and check that the contract agrees with you.
subscribe on AWS Marketplace