The financial math your product can’t afford to get wrong — already built, and already checkable.
AMT on an option exercise. The Social Security taxation cliff that collides with a Medicare bracket. A refinance break-even, a Roth conversion, a longevity horizon. Models like these answer over one REST call, one MCP connection, or one script tag, and each ships with a published spec, a second implementation that had to agree with the first, and constants traced back to the statute that set them. Then hand a number back to us — ours or yours — and we’ll check it, grade it, or turn it into a document you can file.
no API key · three models free · see pricing
✓ what every response looks like
| targetAmount | $25,200 |
| monthsToGoal | 25 |
| interestEarned | $1,431.38to the cent |
| specVersion | 1.0.0behavior pinned |
| record.sha256 | 29d48bd8…storable proof |
From mortgages and retirement through equity comp, federal tax and longevity — plus claim verification, engine grading, print-ready computation reports, per-model evidence packs, and the open FinPlanBench leaderboard. All of it on the same specs.
A model isn’t a formula. It’s six artifacts that have to agree.
Every model in the catalog ships all six, which is why a longer catalog never makes any single model thinner.
A versioned spec
Exact formulas, valid input domains, assumptions, and what the model deliberately refuses to model — published before the code was written.
A second implementation
Rebuilt in another language from that spec alone, by a route that never sees the production code. Two independent readings of the same contract.
250 deterministic cases
Hand-picked edge cases plus seeded random fill, diffed between the two implementations on every change at one part in a billion. One disagreement stops the release.
Sourced constants
Every limit, bracket and factor traced back to the Rev. Proc., the statute, or the agency table it came from, with the date a human last read it.
A changelog entry
Behavior only moves with a version bump and a public note — our own bug fixes included, described plainly enough to be embarrassing.
A hashed record
A SHA-256 over the model, version, inputs and outputs, returned with every run. Store it, recompute it in three years, and prove nothing moved.
The five models people currently get wrong in a spreadsheet
Equity compensation and retirement-income timing are where planning math stops being arithmetic and starts being statute. These five are federal, planning-grade, and each one publishes what it refuses to model. They are the reason a spec is worth more than a formula.
- AMT on an ISO exercise-and-holdiso-exercise
The §56(b)(3) preference, the TY2026 exemption and its 50-cents-on-the-dollar phaseout, the two-rate schedule — and the largest clean exercise, to the share.
- QSBS §1202 exclusionqsbs-exclusion
All four regimes, including the OBBBA three-, four- and five-year tiers and the greater-of cap. Character only — it never invents tax dollars it can't defend.
- 83(b) election, elected vs. not83b-election
Over a real vesting schedule. It will tell you the election saves nothing at zero growth and still puts tax at risk — it doesn't flatter the popular answer.
- Wash sales under §1091wash-sale
Deterministic lot math, calendar-free by design. The exclusions section is longer than the formula, and that is the point.
- IRMAA × Social Security taxation × ACA subsidyretirement-income-cliffs
Two distinct MAGI definitions, three interacting cliffs, a true marginal rate, and the distance to the next cliff in dollars.
One case, hand-computed from the Rev. Proc.
Single filer, $200,000 of taxable income, 100,000 incentive stock options at a $2 strike and $6 fair market value:
AMTI = 200,000 + 400,000 = 600,000
exemption = 90,100 − 0.5 × 100,000 = 40,100
AMT base = 559,900
tentative minimum tax = 151,882
− regular tax 40,598
AMT owed = 111,284
Every figure in that arithmetic is in our registry with its primary source and check date — the exemption from IRS Rev. Proc. 2025-32, §2.10 Exemption Amounts for Alternative Minimum Tax. The engine produced it, a second implementation produced it independently, and it sits in the spec as a worked anchor so you can reproduce it before you ever call the API.
It also answers the question a planner actually asks: 11,561 shares is the largest exercise this year that owes no AMT at all, exact to the share. Exercise the whole grant instead and the bill lands at 27.8% of the paper gain — money owed on stock nobody has sold.
And what it won’t do. This model treats taxable income as its own AMTI base, which means when your AMT-disallowed deductions are large it understates the AMT. That is written into the spec, in those words, because a planning tool that hides its own weak assumption is worse than no tool. Capital gains, the §53 credit, disqualifying dispositions, state AMT: all named exclusions, not silent gaps.
Computation that shows its work — and why that’s the product.
We didn’t add products. We found what else a verified model is good for.
Everything below runs on the same spec, the same 250 cases and the same record you just saw. Nothing here is a separate engine, a separate team, or a separate thing to maintain — which is exactly why we can offer all of it.
Run it
POST JSON and get outputs, edge-case notes, assumptions and the constants used. Or connect the MCP server so an assistant runs the real model instead of approximating one. Or drop in the finished calculator with a script tag. Same engine under all three.
Ask it
Send a claim and get verified, violated or out-of-scope back, with the engine’s own value as the proof. That third verdict is the honest one: we never rule on a number the model doesn’t compute.
Test against it
Keep your engine. Post your inputs and your answers and get a pass/fail per case at the tolerances our CI runs — or download the case files and diff offline. Agreement gives you a regression suite; disagreement gives you a bug worth finding.
Print it
Any run renders as a print-ready report carrying the exact payload its own hash was taken over — so the file can be checked with nothing but the file. It documents a computation; it doesn’t claim to satisfy anyone’s recordkeeping rule.
Score with it
The same cases, pointed at language models instead of at ourselves. FinPlanBench publishes what happens when a model gets the spec and has to produce the exact number. The ground truth is the artifact you’ve been reading about.
Three steps, no keys, nothing to install
This is genuinely the whole integration.
Read the spec
Browse the catalog — inputs, valid ranges, formulas, assumptions, exclusions. You know what you’re integrating, and what it won’t claim, before you write a line.
Call it — or drop it in
POST JSON from your backend, connect the MCP server to your assistant, or embed the finished calculator with a script tag. Same Concordance-tested engine underneath all three.
Keep the receipt
The response carries its spec version, assumptions, sourced constants and a hash — which is what lets you later verify a claim against it, render it as a document, or re-check the record.
// or the no-backend version — a live verified calculator, on your page:
<div data-worthune-embed="social-security-timing"></div>
<script async src="https://worthune.com/embed.js"></script>The same six artifacts, across the decisions a product has to answer
Eight families, so you can tell in ten seconds whether the decision you need is already built. Two of them are new this month.
Whatever you’re holding, there’s a short path in
The engine is the same for everyone — the fastest way to it depends on what you’re building.
Fintech & wealthtech teams
Planning features on the roadmap, no appetite to build and re-verify an engine every tax year.
start with the API →AI & agent platforms
Copilots that discuss money can't improvise it. Compute first, then verify before you speak.
start with MCP →Equity-comp & tax platforms
AMT, QSBS and 83(b) math with the statute cited and the exclusions published — planning-grade, federal.
see the tax pack →Teams who already built it
Keep your engine. Grade it against ours case by case and find out which of you is wrong before a customer does.
start with grading →Banks, insurers & advisory firms
Client-facing calculators this quarter — one script tag, no engineering project.
start with embeds →Proof is a set of artifacts, not an adjective
Every claim on this page resolves to something you can open, download or re-run — that’s the point of the whole system. This table is the map.
| The claim | What enforces it | Check it yourself |
|---|---|---|
| ✓You know what it computes | Every model's contract is public: inputs, units, valid ranges, sentinels. Full specs — exact formulas, assumptions, exclusions — are published for the three sample models, and come with your key for the rest. Out-of-range inputs are rejected with errors — never silently adjusted. | GET /models/{model} |
| ✓The math is independently reimplemented | Concordance testing: a second implementation, built from the published spec alone, must agree with the production engine on 250 cases per model, re-checked on every change. Any disagreement stops the release. | how Concordance testing works |
| ✓The constants are sourced and dated | IRS limits and brackets, SSA factors and life tables, CMS Medicare tiers, HHS poverty guidelines — each with its primary source, its effective period, and the date a human last checked it. Models that consume them cite them in the response. | GET /api/v1/facts |
| ✓The limits are published too | Every spec has an exclusions section written to be read by a skeptic — the AMT model states in plain words that it understates AMT for heavily-deducting filers. We publish the boundary of our own claim, which is the one thing a competitor won't copy. | read an exclusions section |
| ✓It won't change under you | Model behavior changes only with a version bump and a public changelog entry. Responses pin their spec version, so you can hold us to it in your CI. | /models/changelog |
| ✓A verdict is never a guess | Claim checks return verified, violated, or out-of-scope — the third fires whenever a claim touches something the model doesn't compute, and the engine's own value rides along as the proof. | POST /api/v1/verify/{model} |
| ✓You can prove where a number came from | Every response includes a SHA-256 record over the model, version, inputs, and outputs. Store it with anything you build on the numbers; recompute it any time to prove they're unaltered — or paste one in and check it now. | check a record |
| ✓The benchmark can't flatter us | FinPlanBench renders only committed runner artifacts — no artifact, no row, and an empty leaderboard renders honestly. Case sets are hash-pinned, the runner is public, and every provider deviation is recorded in the run. | the leaderboard |
| ✓Even our traction is checkable | We ask you to trust our numbers, so ours are public: aggregate API and MCP usage, updated daily, no vanity math. | GET /api/v1/telemetry |
Priced on the artifacts, never on the arithmetic
3 models are free to call — no signup, no key — and the whole proof stack works on them: run, verify, grade, report, check a record. There is no run meter, and there won’t be.
- Three full models, keyless
- Their specs and case files, open
- Run, verify, grade and report on those three
- Public record check, always free
- Keep the badge where users see results
- The whole catalog, over API and MCP
- Every spec and every case file
- Unbranded embeds and API results
- Verification, grading and reports
- Pin a spec version; usage dashboard
- Custom models, spec'd and Concordance-tested
- Custom case sets and a facts feed
- Evidence packs for vendor review
- White-label calculators and flows
- Contracts, DPAs, compliance documentation
The questions a careful buyer asks
You do a lot of things. Are any of them deep?
One thing is, and everything else is that one thing pointed somewhere new. The deep part is a model with a published spec, a second implementation built independently from it, 250 diffed cases, sourced constants, a changelog and a hashed record. Verification, grading, reports and the benchmark all read from that — they aren’t four side projects with four roadmaps. Read a spec end to end and judge the depth yourself.
We already have calculators. Why would we switch?
Maybe you shouldn’t. Grade them instead: post your inputs and your answers, get a pass/fail per case at the tolerances our CI runs. Full agreement hands you a regression suite and a document that says so. A disagreement hands you something worth knowing before a customer finds it.
Are the tax models filing-grade?
No — planning-grade and federal-only, with the exclusions published in each spec. They answer “exercise now or in January,” not “prepare my return.” The wash-sale spec’s exclusions section is longer than its formula, which is the honest shape of that boundary.
Is a computation report a compliance artifact?
It’s a documentation artifact, and it says so on its face. It records what was computed, from which spec version, under which assumptions, with a hash anyone can recheck. Whether that satisfies a specific recordkeeping obligation is a question for your counsel — we don’t claim it does.
What does it cost?
Three models are free to call — no signup, no key, no card — with a visible “Powered by Worthune” where end users see results. The full catalog is $199 a month, and it drops the attribution. Both plans are on the pricing page, in full.
What happens when tax law changes?
We update the registry from the primary source, bump the affected model specs, note it in the changelog, and your integration keeps working — now with current numbers. Each constant block names everything that moves with it: brackets and AMT in the fall, Medicare tiers in November, poverty guidelines in January. That maintenance is the product as much as the math is.
Compute a number, then check it — both in five minutes
Paste either one into a terminal. No account, no key, no sales call — the fastest way to evaluate us is to use us.
# compute
$ curl -s -X POST https://worthune.com/api/v1/models/emergency-fund \
-H 'content-type: application/json' \
-d '{"monthlyExpenses":4200,"targetMonths":6,
"currentSavings":8000,"monthlySavings":650,
"savingsAccountRate":0.042}'# or check a claim someone else made
$ curl -s -X POST https://worthune.com/api/v1/verify/emergency-fund \
-H 'content-type: application/json' \
-d '{"inputs":{…},"claims":[
{"path":"monthsToGoal","op":"<=","value":24}]}'Want to see the models at work before you write any code? Every calculator is a live demo — retirement, rent vs. buy, refinance, and more. Try the model demos →