Financial planning & wealthtech infrastructure.
The engine your product builds on — calculators, a full planning engine, and unified household management, through one API, behind your brand.
no API key · no card · 3 models free · pricing
✓ what every response looks like
| targetAmount | $25,200 |
| monthsToGoal | 25 |
| specVersion | 1.0.0behavior pinned |
| record.sha256 | 29d48bd8…storable proof |
Live in weeks.
One API from a single calculator to a client’s whole picture — two-line embeds, SDKs on npm and PyPI, and MCP so your AI computes instead of guessing. A real model runs in five minutes, no sales call.
Yours completely.
The product conforms to your brand, your UX, and your workflows — never the other way around. Your theme, your disclosures, your domains; we stay invisible. Your clients see you.
Current and provable, forever.
Statutory changes land in our engine — sourced, versioned, re-verified — not on your roadmap. And every number carries evidence it can be held to. Not on your conscience, either.
Calculators. Planning. Unified household management.
Three solutions, one integration. Start with whichever your roadmap needs first — the other two are the same API.
Financial models & calculators
Ship a finished, verified calculator this week — retirement, refinance, AMT on an option exercise, Social Security timing. 57 models across 8 families: embed one with a script tag, call it over REST, or hand it to an AI copilot over MCP.
Financial planning software
Build planning features — or a whole planning product — without building the math. The household engine takes a client’s full picture and returns a year-by-year projection, a longevity-aware Monte Carlo, and 7 strategies that answer together: withdrawal sequencing, Social Security timing, Roth ladders against IRMAA cliffs, pension elections, and more.
Unified household management
One client, every account, one coordinated picture — and it stays true after the plan is made. The household is a living, versioned record: aggregator feeds and bulk import keep it current, drift webhooks fire the day its numbers move, and white-label portals put the whole picture in front of clients under your brand.
All three run on the same engines and the same discipline. A calculator answer and a full plan carry the same evidence record; inputs out of range are rejected with errors, never silently adjusted; and the engines never carry a market view — return assumptions are yours to supply, or labeled illustrative defaults until you do. Start anywhere, add the rest without re-integrating.
The arithmetic is the cheap part. You’re buying everything else.
Any strong engineering team can compute a retirement projection. That was never the hard part — and we’d rather tell you plainly what is.
The rules never stop moving.
A planning engine is hundreds of statutory rules with annual expiry dates: brackets and AMT every fall, Medicare tiers in November, poverty guidelines in January, contribution limits, RMD tables, COLAs. In-house, that’s a permanent tax on your roadmap — every year, forever. Here, each change lands in the engine from the primary source, versioned and re-verified, before your users notice.
Coordination is the hard math.
One calculator is a weekend project. 7 strategies that answer together — withdrawal order against bracket management against IRMAA cliffs against Roth ladders against claiming ages — is the math that moves real client dollars, and the part in-house builds rarely reach. Every recommendation ships with its computed dollar delta and every alternative shown.
AI raised the stakes.
The moment a copilot discusses money, “mostly right” becomes a liability. The fix isn’t a better prompt — it’s a deterministic engine the AI calls instead of guessing. That is exactly what our MCP server hands your assistant.
Someday, someone asks you to prove it.
A client disputes a number. A regulator asks where it came from. Your own QA asks what changed between March and May. Every answer here carries a hashed evidence record, a pinned spec version, and cited sources — the paper trail is built in on day one, never reconstructed under pressure.
One source of truth: computation that can prove itself.
All three solutions, every proof tool, and every way of shipping draw from the same source. Nothing here is a separate product with a separate roadmap.
The verified computation
- ✓A published, versioned spec
- ✓A second implementation, built blind, that must agree
- ✓250 deterministic cases, diffed at one part in a billion
- ✓Constants sourced to the statute, and dated
- ✓A changelog — behavior moves only with a version bump
- ✓A SHA-256 evidence record on every answer
Proof is a set of artifacts, not an adjective.
Every claim on this page resolves to something you can open, download, or re-run. Four of the claims here — the full ledger, with a check for every one, is a click deeper:
| The claim | What enforces it | Check it yourself |
|---|---|---|
| ✓You know what it computes | Every contract is public: inputs, units, valid ranges — and what each model refuses to model. Out-of-range inputs are rejected with errors, never silently adjusted. | GET /models/{model} |
| ✓The math is independently rebuilt | A second implementation, built from the published spec alone, must agree with the engine on 250 cases per model at one part in a billion. A disagreement stops the release. | how Concordance testing works |
| ✓The constants are sourced and dated | IRS, SSA, CMS, HHS — each figure with its primary source, its effective period, and the date a human last read it. Models cite the facts they used, in the response. | GET /api/v1/facts |
| ✓You can prove where a number came from | Every response — model or household — carries a SHA-256 over model, version, inputs, and outputs. Recompute it any time; paste one in and check it now. | check a record now |
Four ways to ship. The same source underneath.
Lightest first. They compose — most builds use two or three.
Embed it
Two lines of markup on any page — a script tag or a web component. Calculators and household widgets, framed, disclosed, self-sizing.
Call it
REST from your backend, SDKs on npm and PyPI, signed webhooks when stored plans drift. POST JSON, get the number and its receipt.
Connect an agent
MCP-native: an assistant can create a household, project it, run the strategies, and verify its own claims — computing first, speaking second.
Make it yours
The React kit plus white-label tenant config: your brand, your theme behind a WCAG gate, your disclosures appended, tenant-bound embeds on your domains.
<div data-worthune-embed="household-overview"></div>
<script async src="https://worthune.com/embed.js"></script>Bringing a book of clients? Bulk import migrates from any legacy system: dry-run first for the complete error worklist, idempotent re-runs, and an honest role for AI — it drafts the mapping, determinism executes it. See the docs.
Three doors into the same room.
Product & engineering teams
Wealthtech and fintech with planning on the roadmap and no appetite to build and re-verify an engine every tax year. Start with one model; grow into households.
start with the API →AI & agent platforms
Copilots that discuss money can't improvise it. Real computation over MCP, claim verification before the agent speaks, and a benchmark that shows why both matter.
start with MCP →Institutions & their agencies
Banks, insurers, and advisory firms shipping client experiences under their own brand — white-label theming, appended disclosures, a reference build to fork, and migration for the book.
start with the reference build →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. There is no run meter, and there won’t be.
- 3 full models, keyless
- Their specs and case files, open
- Run, verify, grade, and report on those three
- Public record check, always free
- Both engines: the whole catalog and households
- API, MCP, SDKs, embeds, webhooks
- Bulk import for migration
- 250 active households included
- Unbranded embeds and API results
- White-label: your brand, theme, and disclosures
- Tenant-bound embeds on your domains
- Attribution removal
- 2,500 active households included
- Priority support, first access to new families
The questions a careful buyer asks
Why not build this in-house?
You could — the arithmetic genuinely isn’t hard, and we won’t pretend otherwise. But the engine is the smaller half of the work: staying current every tax year, re-verifying everything after each change, reaching the coordination math, and defending numbers under dispute is a permanent team, not a project. Buying that back lets your engineers build what actually differentiates you.
How fast is “live in weeks,” really?
An embedded calculator: the same day, two lines of markup. Planning features over the API: a sprint. A white-labeled client portal: weeks, starting from the reference build. And the free tier means you prove all of this on real calls before paying anything.
Is this three products?
No — three solutions on one platform. Calculators are single decision models; planning and unified household management are the household engine at two moments in a client’s life. Same specs, same constants, same evidence records, one integration — and the pricing doesn’t split them.
Is any of this financial advice?
No. The engines compute; they don’t recommend, and they carry no market view — return assumptions are yours to supply, or labeled illustrative defaults until you do. Every decision surface shows the alternatives, not just the winner.
We already built our own engine.
Then grade it: post your inputs and answers, get a pass/fail per case at the tolerances our CI runs. Agreement hands you a regression suite; a disagreement hands you a bug worth finding before a customer does.
What happens when tax law changes?
We update the registry from the primary source, bump the affected specs, note it in the changelog, and your integration keeps working — now with current numbers. That maintenance is the product as much as the math is.
Compute a number, then check it — both in five minutes.
Paste it 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}'Want to see it before you write any code? Every calculator is a live demo, and the planning engine runs end to end on a labeled fictional household. Try the calculators → See a full plan →