The application is the URL
Here is a tool for choosing a mortgage term:
https://upshot.fyi/v2/#a=Which+mortgage+term+to+take&h=Compare+payments+across+mortgage+terms&v=Assumes+a+fixed+positive+rate+and+monthly+repayments+throughout+the+selected+term%2E&m=GPT-6&d=2026-09-16&g=Your+term&s=months:300:25+years&s=months:360:30+years&s=months:420:35+years&g=Your+loan&i=loan:250000:Amount+borrowed&i=apr:4%2E5:Interest+rate&r=rate:apr/100/12:&r=pay:loan%2Arate/%281-pow%281+rate%2C0-months%29%29:Monthly+payment&r=interest:pay%2Amonths-loan:Interest+over+the+term&u=loan:%C2%A3&u=apr:%25&u=pay:%C2%A3&u=interest:%C2%A3
That is not a screenshot. It's a renderer, running the link above, inside this page. Click 35 years. The payment falls by £206 a month and the interest rises by £80,045. The magic is that the whole thing lives within its own URL.
Change anything on it and the URL changes with it, so you can send it on and the next person opens your version, with your numbers in it. The whole thing is 524 characters.
There is nothing behind it. No server, no database, no account, no build step, no dependencies. The tool is the string.
Making one is a sentence
You are already in ChatGPT or Claude, working something out. You type:
dinner was 80 between the three of us. make me something I can put my own numbers into. read https://upshot.fyi and export this
ChatGPTupshot.fyi/v2/#a=Splitting+dinner+three+ways&h=Split+the+bill&v=Divides...Nothing installed at any step
The model fetches the static page, reads instructions, writes a URL and hands it back. You click it. That is the product. Nothing to install: no agent skill, no MCP server, no API key. All you need is the browser and chat app you already have. No account, no signup. It works in chat apps I have never tested and in models that did not exist when I wrote it, because the only thing being integrated is a page.
Upshot never calls a model. You do, in a window you already had open.
Nothing you type leaves the browser
Everything after the # stays on your machine. No server
ever sees the card.
Two things fall out of that.
It costs nothing to run. One static file on a CDN. A million people open a million different tools and it is still one file. Nothing to store or scale.
I cannot touch a card once it is sent. No takedowns or patches. If someone pasted a card into a group chat in March, that chat is the only copy and I will never know it exists.
The same product built the ordinary way needs somewhere to put the card. Ours just uses the link.
The real spec is WhatsApp
A card gets sent to somebody, and a link carrying arithmetic gives a chat app plenty to chew on.
- A matching pair of
_is eaten as italic before anyone clicks. So is*, so is~. The formulaj*45arrives asj45, meaning something else entirely. - Autolinkers also cut the link at the first character that is not legal
in a URL, and
<and>do it.
So everything is percent encoded except letters, digits, a hyphen and the
+ - / = doing the arithmetic.
The one that stung: the renderer used to write edits back into the URL
with ~ between them, so the card you just changed is now a
non-tappable link. You only find that by sending yourself a few hundred
messages.
It stopped being a format and became a language
The first version drew a fixed layout. Then it needed a checkbox. Then a number that feeds another number. Then a line that changes what it says when you cross a limit. Somewhere in there it turned into a small UI language.
The whole vocabulary is nine keys.
This only works now. Nobody was ever going to hand-write 600 characters of exact syntax to split a bill. What makes it miserable to type makes it easy for a model to generate.
Nothing in it describes appearance. Two cards from two different models, months apart, still look like they came from the same place. The model chooses what a card says, never how it looks.
Formulas can use any name on the card, so each card is basically a tiny spreadsheet. That is enough to cover things like loans, tax, conversions and most everyday calculators.
The prompt is the product surface
The model gets one file of instructions at upshot.fyi/llms.txt. Getting that file reliable took more work than expected.
The biggest lesson was that examples beat rules. If a rule says one thing and an example does another, models will regularly follow the example. Every example is part of the spec whether you intended it to be or not.
Rules also need one home. Repeat the same rule three times with slightly different wording and you have not reinforced it, you have given the model three versions to choose from. And rules work better when they say what to write, rather than what to check or avoid afterwards.
Most of this is hard to reason about in advance. Change one thing, generate a hundred cards with different models and read them. The renderer can tell you whether a URL is valid. It cannot tell you whether the model wrote the right thing.
The version is in the path
/v2/ is the current renderer. /v1/ is frozen
and still serves the cards written against it. Any change that would make
an existing card parse, calculate or draw differently does not get made.
It gets a /v3/ and a new file.
So every new key has to be worth freezing forever, in public, with no way to take it back. Almost nothing is. That rule has killed more features than good taste ever would.
The renderer
One HTML file. 67 KB, 22 KB over the wire. No dependencies, build step or framework.
It reads the card from the URL, validates it, works out the formulas and draws it. Change an input and it recalculates everything and writes the new state back into the URL.
If a card does not make sense, it refuses in place and says exactly what is wrong: "bill" names two things on this card. Paste that back into the chat and the model can usually fix its own mistake. Makes for a tight feedback loop.
Formulas go through a small parser written by hand. There is no
eval because the input is a string off the internet.
Results can depend on other results in any order. The renderer works out the dependencies and calculates them as they become available. If one value cannot be worked out, it shows a dash and the rest of the card still works.
What it never checks is whether the numbers are true. Give it last year's tax bands and you get last year's tax bands, rendered perfectly. That belongs to whatever wrote the card, not the renderer.
What it costs
- About 2000 characters. URLs top out at around 2,000 characters in practice. Most cards land between 600 and 1,000. There is no compression because the model needs to write the URL and you need to be able to read it.
- No privacy beyond "it is a URL". Anyone with the link can read the card, and it can sit in browser history and chat logs.
- No free text, no charts, no images, no network. The list of keys is deliberately closed. Keep adding one for every use case and this becomes a framework.
- No way to fix a card after you send it.
Why it holds up
The useful part is that the whole tool is one string you can read, paste, edit and send. The only thing needed to run it is a browser.
For small tools, that turns out to be enough surprisingly often.
The renderer, language and tests are on GitHub. The contract is at llms.txt, and /made/ has examples. Send a card and it goes up there too.