frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Open in hackernews

Launch HN: Tokenless (YC S26) – Automatic model switching to save money

https://usetokenless.com/
16•rohaga•1h ago
Hi HN, Rohit here from Tokenless (https://usetokenless.com/), which I’m building alongside co-founders Andrew and Kev. We’re building an API gateway which routes agent traffic dynamically turn-by-turn between different models to save on AI spend.

The cost of AI tokens is top-of-mind for many. Companies like Uber and Salesforce have been complaining about blowing their yearly AI spend faster than expected.

Frontier models are amazing for dev work, but are so expensive. Open-source models are cheap and rapidly improving, closing the gap with frontier models, but aren’t quite there yet.

Tokenless gets you the best of both worlds–routing harder turns to smarter models only when needed, which keeps costs low.

Before Tokenless, I was doing a PhD at Princeton. While using coding/other agents, I constantly agonized over model choice, to make sure my AI spend was going as far as possible on my academic Cursor account.

At the same time, I was doing LLM research, and a small technique I developed while in recovery from NeurIPS submission season seemed to hit SOTA pretty fast. I was surprised that such simple ideas could do routing well.

We’ve been able to develop a version of the router that matches the performance of Claude Fable 5 at half the cost. The blog post on our website explores the technical details on how we did this (https://usetokenless.com/blog/building-tokenless/).

Highlights: - Our approach queries multiple models at once and uses their progress to make decisions (this technique is novel AFAIK, let us know if you know anyone else doing this). - Switching models doesn’t destroy the cache if the routing algorithm is aware of when the cache is hot/cold.

To come: - Adding Kimi K3, all other GPT efforts and more to the router

Go ahead and sign up on usetokenless.com and try using Tokenless with your agent, you’ll get $20 of free credit. Here’s a demo on how to use it: https://youtu.be/sjZWriclcls

Tokenless provides frontier-level intelligence for cheaper, so we’d love some feedback on how it feels to use, any corner cases that the router routes incorrectly, and whether you find the routing problem interesting!

Comments

mediaman•49m ago
So this only switches models if the cache is cold, because otherwise the economics of switching don't work. But most agentic work involves long strings of successive tool calls that benefit from a hot cache. Hot cache calls reduce input cost by 90%. This can basically only deliver cost savings in turns where the AI delivers a result to the user, the user waits at least 5 minutes (or the length of the cache), and then responds.

But user->AI calls are very much the rare case now, the more agentic the workload. Most of them will be tool->result->tool without the user involved. And token burn is highest with these long running agentic chains, but that's precisely where routing doesn't work because of the KV cache.

How do you deal with that?

rohaga•43m ago
> So this only switches models if the cache is cold

Not exactly. It can also make sense if the cache is hot to switch models. For example, we might currently be on Deepseek and the next task is SO HARD that it doesn't make sense to not use frontier (1 turn to crack versus 100 turns for Deepseek to crack). Likewise, the router may judge that it's likely that the next few set of tool-calls will be ridiculously easy, and so switching to Deepseek will save over time.

Remember that Deepseek can be something like 30x cheaper even cold.

There is a more fine-grained view of caching here, because each model can have a different amount of the prefix already cached as well (since we were switching a bunch) so even if the cache is somewhat warm it may make sense to switch.

ignoramous•17m ago
> the next task is SO HARD that it doesn't make sense to not use frontier

How does tokenless quantify "so hard"?

> 1 turn to crack versus 100 turns for Deepseek to crack

Interesting definition for a "frontier". What is a "turn" here? Token count? Request count? Context-based?

I've found that MiniMax M3 (a smaller model at 295b) will code up better when DeepSeek v4 Pro (1.2t) will not (and vice versa).

rohaga•11m ago
Highly encourage you to read the blog post (https://usetokenless.com/blog/building-tokenless). Essentially, we estimate the confidence of a specific model failing or succeeding on a specific task using our own foundation models.

A turn here is a tool call/user input, anything that causes the model to get some new input. We're working on adding Minimax M3 and other models. We think that people have some intuitions about which models are good when--we seek to quantify them scientifically.

grim_io•40m ago
How can you be cheaper if you query multiple models at once, compared to me just using a single model, which will always have the correct caching configured?
rohaga•36m ago
If we cut off an unconfident/expensive model early in thinking, then we don't have to pay for additional thinking cost at all. For many tasks, this is quite a large saving.

That being said, whatever models we select to race at any point will ALL have their cache updated, so if they're chosen on the next race they'll be a lot cheaper.

grim_io•28m ago
Maybe I'm misunderstanding, but this seems to oversimplify the problem.

Most frontier Models won't show you their true reasoning, but only a summary.

There is also no reason you can automatically assume the quality and price of the outcome based on the first few reasoning trace summaries.

If you look at the recent model releases, it becomes clear that the trend is that the largest models provide the most cost-effective solutions, because of the massive turn/tool call/reasoning reduction needed to find the solution, compared to cheaper and smaller models.

rohaga•20m ago
Our research seems to indicate you can get a decent signal based on the first few reasoning trace summaries. We analyzed hundreds of billions of tokens to figure this out. Any open-weights model also gives you reasoning, which is very helpful (because they are usually lower-quality candidates you would want to cut off early)

The largest models are very well known for having large reasoning traces. The thing that cracks down on overthinking is reasoning-effort training, which is largely a function of how the model is trained (certain RL objectives/teachers) rather than size of the model. The Kimi K3 technical report has some excellent work on this: https://arxiv.org/pdf/2607.

crazytweek•24m ago
Our approach queries multiple models at once and uses their progress to make decisions (this technique is novel AFAIK, let us know if you know anyone else doing this)

Sounds like DigitalOceans Model synthesis (https://www.digitalocean.com/blog/model-synthesis) or AilinOne (https://ailin.guide/) ?

sarjann•21m ago
Sounds like this would be expensive on the input token side with some saving on the decode side. For workloads with large documents / context that could be an issue.
crazytweek•18m ago
AFAIK they solve this through their RAG based knowledgebases to only search and use the most relevant Information.
random17•15m ago
These approaches, along with OpenRouter Fusion (https://openrouter.ai/blog/announcements/fusion-beats-fronti...) are different from ours in that:

1. we trained custom models to predict LLM performance (this performs much better than asking LLMs directly to predict performance)

2. we cut off model responses early if they are not performing well, saving on costs versus running them to completion

3. finally we serve the unmodified output of the chosen model, instead of synthesizing the outputs into one, which makes us a model router

sarjann•23m ago
If it only switches when cache is cold, it seems like it'd lock in one model for the whole session?

What use case are you imagining where cache eviction would happen during it? It might also be the case that a task might seem easy but then it ends up becoming hard for certain parts. For spawning subagents I could see this being useful maybe.

MikhailTal•21m ago
It's a smart approach, definitely interesting. It all hinges on quality of course which im not convinced.

τ³-Banking is the only one which you show better accuracy and cheaper. If i'm reading the blog results right, for deepswe and terminalbench, you are worse+cheaper than frontier, and better+more expensive than just small models. Which is exactly what i would expect even for a router that switches at random.

Speaking of random routing, this would be a great ablation study as well. What about also if you route each request to a tiny 7B model classifier? Why is your approach SOTA?

JoshTriplett•14m ago
> Tokenless fans out your request to a group of models and watches them think. Once a model is clearly on track

By the time the model is "on track", it will have already received the input tokens. To a first approximation, input tokens are often the bulk of the cost for many queries, and this would increase the cost for such queries. It seems like it'd only decrease costs for prompts where you feed a relatively small amount of input into the model first and can tell whether the model is "on track" before it starts reading larger amounts of input data.

rohaga•8m ago
Well, you can estimate the confidence BEFORE you start the task, too. That way you can restrict your trajectory to just a few models.

We also think there are tons of people working on "context management"--e.g. retrieval systems, prompt compression, log compression, etc. We want to work harder on the "decode" side as we think there are lots of savings to be made

Show HN: Open-source engine running Gemma 4 26B in 2 GB RAM on any M-series Mac

https://github.com/drumih/turbo-fieldfare
216•gitpusher42•1h ago•53 comments

Superlogical – Mitchell Hashimoto

https://mitchellh.com/writing/superlogical
85•tambourine_man•1h ago•11 comments

KOReader

https://koreader.rocks/
495•Cider9986•5h ago•161 comments

Handbook.md shows that long policy documents do not reliably govern agents

https://arxiv.org/abs/2607.25398
187•spIrr•3h ago•120 comments

Mitchellh starts a new company: Superlogical

https://www.superlogical.com/
64•yan•1h ago•18 comments

Hugging Face: Anatomy of a frontier-lab agent intrusion

https://huggingface-anatomy-of-frontier-lab-model-intrusion.static.hf.space/index.html
54•dn2k•1h ago•16 comments

Launch HN: Tokenless (YC S26) – Automatic model switching to save money

https://usetokenless.com/
16•rohaga•1h ago•17 comments

Hamburg's Stadtpark: A Park Built to Be Used

https://alsterrunde.com/hamburgs-stadtpark-a-park-built-to-be-used/
33•mertbio•2d ago•2 comments

Keychron announces first open-source firmware for gaming mice

https://www.digitalfoundry.net/news/2026/07/keychron-announces-first-open-source-firmware-for-gam...
7•JLO64•21m ago•3 comments

Shipping Godot VR and Porting to PSVR2: A Partial Post Mortem

https://www.claire-blackshaw.com/blog/2026/07/shipping-godot-vr-and-porting-to-psvr2-a-partial-po...
66•ibobev•4h ago•0 comments

Document-borne AI worms can self-propagate through Copilot for Word

https://enklypesalt.com/posts/context-collapse-part3-ai-worming-through-word/
220•Canopy9560•5h ago•178 comments

Hunter-gatherers introduced fish to a mountain lake 7000 years ago

https://www.newscientist.com/article/2580119-hunter-gatherers-introduced-fish-to-a-mountain-lake-...
82•stevenwoo•2d ago•55 comments

Cesium DevCon 2026 talks are up, including a keynote from SQLite's creator

https://cesium.com/events/cesium-developer-conference/2026/
22•jasteinerman•1h ago•2 comments

Darktable

https://www.darktable.org/
149•siatko•4h ago•77 comments

GPT-5.6 vs. Claude Fable 5 for Physical AI, which performs best?

https://juliahub.com/blog/frontier-models-physical-ai-evaluation
30•mbauman•2h ago•5 comments

Self-hosting Kimi K3: 20% more hardware cost, 20% better task resolution

https://aistack.imec-int.com/blog/gpu-self-hosting
27•flifenstein•2h ago•7 comments

Show HN: Kedge – Full-stack cloud with forkable VM snapshots and global SQLite

https://kedge.dev/
13•wgjordan•42m ago•1 comments

More Tailscale tricks for your jailbroken Kindle

https://tailscale.com/blog/jailbroken-kindle-proxy-tun-modes
352•Error6571•11h ago•100 comments

Amiga Graphics Archive

https://amiga.lychesis.net/index.html
115•Bluestein•6h ago•19 comments

Disrupting supply chain attacks on NPM and GitHub Actions

https://github.blog/security/supply-chain-security/disrupting-supply-chain-attacks-on-npm-and-git...
63•nyku•4h ago•19 comments

Show HN: Qwen Scribe – local transcription and dictation for Apple Silicon

https://github.com/VladUZH/qwen-scribe
20•sidclaw•2h ago•3 comments

User Interfaces of the Demo Scene

https://www.datagubbe.se/scenegui/
347•zdw•12h ago•57 comments

SQLite in Production: Optimizing WAL Mode, Concurrency, and VFS Layers

https://micrologics.org/blog/sqlite-in-production-optimizing-wal-mode-concurrency-and-vfs-layers-...
195•ankitg12•9h ago•61 comments

Ask HN: My domain registrar (Hover) rug-pulled me for $3000

34•shrinks99•1h ago•27 comments

SpecForge – A Platform for Authoring Formal Specifications

https://docs.imiron.io/v/0.5.10/en/tour.html
62•agnishom•6h ago•7 comments

CipherX applies painless permanent tattoos with dissolving microneedle patches

https://www.designboom.com/technology/cipherx-painless-permanent-tattoos-dissolving-microneedle-p...
11•surprisetalk•2h ago•5 comments

Baseload Is a Myth (2024)

https://cleanenergyreview.io/p/baseload-is-a-myth
7•thecopy•1h ago•4 comments

Lisp moving Forth moving Lisp

https://letoverlambda.com/textmode.cl/guest/chap8.html
95•fallat•2d ago•23 comments

I Want to Leave the Internet

https://chupacabra.bearblog.dev/i-want-to-leave-the-internet/
7•Looky1173•49m ago•0 comments

Google shuts down Nobel Prize winning AlphaFold

https://www.engadget.com/2225849/google-shuts-down-alphafold/
49•NordStreamYacht•2h ago•6 comments