MurphyA/hacker-news huggingface dataset:
Show HN: Entropy-Guided Loop – How to make small models reason
by andrewmonostate | 2025-09-03 17:19:10+00:00
TLDR: A small, vendor-agnostic inference loop that turns token logprobs/perplexity/entropy into an extra pass and reasoning for LLMs.

- Captures logprobs/top-k during generation, computes perplexity and token-level entropy.

- Triggers at most one refine when simple thresholds fire; passes a compact “uncertainty report” (uncertain tokens + top-k alts + local context) back to the model.

- In our tests on technical Q&A / math / code, a small model recovered much of “reasoning” quality at ~⅓ the cost while refining ~⅓ of outputs.

I kept seeing “reasoning” models behave like expensive black boxes. Meanwhile, standard inference already computes useful signals both before softmax normalization and after it(logprobs), which we usually throw away. This loop tries the simplest thing that you could think of: use those signals to decide when (and where) to think again.

GitHub (notebook + minimal code): https://github.com/monostate/weave-logprobs-reasoning-loop

Paper (short & engineer made): https://arxiv.org/abs/2509.00079

Blog (more context): https://monostate.ai/blog/entropy-refinement-blog

Requirements: Python, API that exposes logprobs (tested with OpenAI non reasoning 4.1). OPENAI_API_KEY and WEAVE for observability. Run the notebook; it prints metrics and shows which tokens triggered refinement.

- Python, simple loop (no retraining).

- Uses Responses API logprobs/top-k; metrics: perplexity, max token entropy, low-confidence counts.

- Weave for lightweight logging/observability (optional).

- Passing alternatives (not just “this looks uncertain”) prevents over-correction.

- A simple OR rule (ppl / max-entropy / low-confidence count) catches complementary failure modes.

- Numbers drift across vendors; keeping the method vendor-agnostic is better than chasing fragile pairings.

- Needs APIs that expose logprobs/top-k.

- Results are indicative—not a leaderboard; focus is on within-model gains (single-pass vs +loop).

- Thresholds might need light tuning per domain.

- One pass only; not a chain-of-thought replacement.

- Run it on your models and ideas (e.g., 4o-mini, v3, Llama variants with logprobs) and share logs in a PR for our README in GitHub if you'd like, PRs welcome - I’ll credit and link.

Overall let me know if you find making small models reason like this useful!
by dragonwriter | 2025-09-03 17:19:17+00:00
The tipping point on the dotcom bubble itself was the NASDAQ market peak on March 10, 2000, the tipping point on the broader economy that the bubble bursting helped contribute to was the economic peak in March 2001 that marked the start of the March-November 2001 recession.

A number of government policies adopted before the bubble burst under Clinton and before the bubble bursting had worked its way into the public consciousness under Bush (safett net cutbacks, downward tax burden shifts, etc.) made the November 2001-December 2007 aggregate expansion after the 2001 recession and before the Great Recession have very poor distributional characteristics, such that much of it, especially the first couple years, felt like a recession for most outside of a narrow elite, which probably combines with the emotional impact of 9/11 to fix that late date as the beginning of the downturn, even though it was near the end of the downturn in aggregate economic terms.
by FabHK | 2025-09-03 17:19:30+00:00
Designed for ease and efficiency of reading and to make letters unambiguous by "maximising the distances between forms to allow for easy, clear identification of each character" [0, p. 7]. Compare FE-Schrift [1], which is designed for number plates to make letters unambiguous in the sense of hard to convert one into another by masking or adding parts:

[0] https://github.com/polarsys/b612/blob/master/docs/B612-Leafl...

[1] https://en.wikipedia.org/wiki/FE-Schrift
by aseipp | 2025-09-03 17:20:07+00:00
Yes, a GUI for settings is nice if only for one thing: so there can be a search box that you can use to search over all the settings to find what you need in a pinch. It's a lot friendlier if I can do something like "Open Settings > Ctrl+F > 'Font'" or whatever than having to go find the manual and look it up.

I don't care about the configuration language so much personally (though JSON is of course pretty lame in a lot of ways for that task.)
by kenhwang | 2025-09-03 17:21:05+00:00
> Curious as someone dabbling with building an editor: what do you prefer? A different configuration language? A GUI? How do you save and sync settings? Just with JetBrains account sync?

Really just a GUI for editing, the storage format can still be JSON and synced/backed up however you handle text files.

It just really nice having settings grouped by categories, with dropdowns for possible values, indicators for changes from default values or values overridden by project settings, search/hide/filters, and tooltips for what it does.

Right now the experience with Zed is: open the settings file, open the default settings file for documentation, and basically use search and copy-paste magic value strings/int/float/nulls into the right nested object/key.

> Is Zed's "zoom in" feature (shift-escape) that quickly maximises the active pane (excluding the file browser/git pane) enough? Or are you looking for the separate window experience of IntelliJ? (e.g. JetBrains lets you pop-out the commit window, I believe, which can be nice since once you close it you're back in the editor with nothing to switch or rearrange.)

Really the separate window experience (including the file browser/git pane). Really nice having the git panel just open on a window so you can quickly glance at changed files and quickly jump back to them for more editing. Or having search results able to spawn tabs in another pane/window so you don't have to keep switching back to search or rearranging the tab after opening the file from it.

Or even just expanding the workspace across monitors. Right now you can't even move tabs into its own window or across windows.
by oceanplexian | 2025-09-03 17:21:13+00:00
I feel like it's totally the opposite.

The differentiator is the fact that the scaling myth was a lie. The GPT-5 flop should make that obvious enough. These guys are spending billions and can't make the models show more than a few % improvement. You need to actually innovate, e.g. tricks like MoE, tool calling, better cache utilization, concurrency, better prompting, CoT, data labeling, and so on.

Not two weeks ago some Chinese academics put out a paper called Deep Think With Confidence where they coaxed GPT-OSS-120B into thinking a little longer causing it to perform better on benchmarks than it did when OpenAI released it.
by hn_acc1 | 2025-09-03 17:21:17+00:00
This. Every "AI is greate" response seems to be from someone doing web development - something I've intentionally avoided ever since I got tired of it around 2001, and hope to never have to do again.

We write C++ code in a very customized internal idiom to drive our hardware. Claude is great at filling in debugging statements / iterating over standard data structures to dump their contents, but not much else.
by mlyle | 2025-09-03 17:21:24+00:00
Almost anything has a utility scale which is diminishing. But we still see MR=MC pricing in industries with barriers to entry (IPR, capital costs). TSMC and Mercedes don't price cheap to avoid giving others a toehold.

> There is a natural monopoly aspect given the ability to train and data mine on private usage data but in general improvements in the algorithms and training seem to be dominating advancements.

There's pretty big economies of scale with inference-- the magic of how to route correctly with experts to conduct batching while keeping latency low. It's an expensive technology to create, and there's a large minimum scale where it works well.
by EGreg | 2025-09-03 17:21:25+00:00
Well, if they have never released open source, they might not be the right developer for us. We don't have to chase after every type of person, we have specific needs.

Having said that, if I was hiring for a big corporation, I'd still get a lot of information from how they interact with the LLMs, and I wouldn't want them to 'game it' a couple weeks in advance so I'd look for older entries. I love how LLMs for the first time give me a real way to assess what people have been doing. And can even use them to vet crazy ideas people send to me.

Here is a real example that I did today, see what I mean: https://chatgpt.com/share/68b878b8-8608-800a-8b6a-6bac1af36e...
by quietbritishjim | 2025-09-03 17:21:38+00:00
First of all: I think it's ok if the definition of fish is a bit blurry around the edges.

But actually I think coelacanths are quite a fun example. I hadn't heard of these before, thank you!

Yes, they're not tetrapods, but (I've just discovered) they're not even vertebrates (no spine). According to my definition, they shouldn't be fish, but they do seem quite fish like.

They are chordates (they have a spinal cord, just no backbone for it), so I could expand my definition to any chordate that isn't a tetrapod. But there are some rather non-fishy chordates [1] so that doesn't work either.

[1] https://en.m.wikipedia.org/wiki/Tunicate

(For those that don't know, the top level subclassification of animals is phylum. There are a lot of phyla but a common ones are chordates (all vertebrates plus a few odd animals like discussed above), arthropods (insects and insect-like things like spiders and crabs), and molluscs (like slugs and clams). When I was at school, animals were just vertebrates or invertebrates but the reality is more interesting. I went down that rabbit hole when I found out that, weirdly, octopuses are molluscs.)
by Terr_ | 2025-09-03 17:21:46+00:00
I'd like to point out that a regime may find it worthwhile to compromise more kinds/sizes of VPNs than we might expect.

The evil regime doesn't need to have a popular evil VPN that everybody uses... it may be enough to operate (or hack) a smaller VPN which can unmask enough dissidents that their friend-groups can be found by other means.
by anonymoushn | 2025-09-03 17:21:55+00:00
These example queries really do take fewer tokens than the SQL queries, and the syntax is apparently designed to minimize token count.

My impression is that letting the model write SQL queries is not a typical baseline for RAG. It's unlikely that a company could substantially benefit from this reduction, because the cost of their internal LLM usage is probably mostly tokens that are not RAG queries or tabular responses. They also probably cannot fall back to a cheaper model because the "minimum acceptable level of intelligence" of the model is likely chosen for tougher constraints than the ability to generate correct RAG queries.

I don't think this is a reasonable thing to make a business around, because the claimed benefits mostly do not exist.

Also, 9 months ago you posted that you were building it, I suppose? https://news.ycombinator.com/item?id=42169086
by devinprater | 2025-09-03 17:22:29+00:00
I use AI, as a blind person. I posted a week or so ago a video in which I use TalkBack's image description feature to play a video game that has no accessibility at all. Of course, that was on Android which isn't the most blind-friendly of OS', and iOS doesn't have LLM image descriptions built in, nor good PS2 emulators.

Other blind people are all in with the AI hype, describing themselves as partially sighted because of AI with their Meta Rayban glasses. Sidenote, Rayban glasses report that I died last year. I somehow missed my funeral, sorry to all those who were there without me. I do like brains, though...

Meanwhile many LLM sites are not blind-friendly, like Claude, Perplexity, and there are sites that try but fail so exasperatingly hard that I lose any motivation for filing reports where I can't even begin to explain what's breaking so hard. It's evident that OpenWebUI have not tested their accessibility with a screen reader. Anyway blindness organizations (NFB mainly) have standardized on just use ChatGPT and everything else is the wild west where they absolutely do not care. Gemini could be more accessible, on web and especially Android, but all reports have been ignored so I'm not going to bother with them anymore. It's sad since their AI describes images well. Thank goodness for the API, and tools like [PiccyBot](https://www.piccybot.com/) on iOS/Android and [viewpoint](https://viewpoint.nibblenerds.com/) and [OmniDescriber](https://audioses.com/en/yazilimlar.php) on Windows. I'm still waiting for iOS to catch up to Android in LLM image descriptions built into the screen reader. Meanwhile, at least we have [this shortcut](https://shortcutjar.com/describe/documentation/). It uses GPT 4O but at least it's something. Apple could easily integrate with their own Apple Intelligence to call out to ChatGPT or whatever, but I guess competition has to happen. Or something. Maybe next year lol. In the meantime I'll either use my own cents to get descriptions or share to Seeing AI or something like a cave man.
by tim333 | 2025-09-03 17:22:42+00:00
I'm not at all convinced that "AI Use Reprograms the Brain, Leading to Cognitive Decline"

Some of the points that LLM users could remember what they wrote and felt disconnected from it are kind of well, duh. Obviously that applies to anything written by someone or something else. If that's the level of argument I very much doubt it supports the LLM leads to cognitive decline hypothesis.

I mean you won't learn as much having an LLM write and essay than writing it yourself, but you can use LLMs and write essays or whatever. I doubt LLMs are any worse for your head than daytime TV or such like.
by timhigins | 2025-09-03 17:22:47+00:00
This was published by an anti-vaxxer/vaccine denier and also seems to be AI-generated. Would recommend linking to the original study instead. The homepage of the site includes articles like "Do Viruses Exist?" "(POLL) 96% support federal control of DC to fight crime" "Autism Spectrum Disorders: Is Immunoexcitotoxicity the Link to the Vaccine Adjuvants? The Evidence" and so does his twitter page: https://x.com/NicHulscher.
by slg | 2025-09-03 17:23:33+00:00
>As a musician, fuck everything about this

Pretty wild to include a comment like this in the testimonials. Sure, you can disagree with the musician on philosophical terms over IP laws and many consumers will always prefer "free", but to put this in your testimonials shows that the developers take pride in the act of pissing off musicians. That just rubs me the wrong way.
by WorldMaker | 2025-09-03 17:23:34+00:00
The Shadow DOM can auto-fill the slots in the case where a web component has slot fillers in the main DOM. You still need JS to invoke/create the shadow DOM, but in that case your JS might be minimal and not need to model the interior structure.

But the big problem that template tries to solve is building DOM fragments that are parsed but not "live" in the open documment. Before the template tag there was no good way to do that other than JS and createElement/createElementNS, and that has always been slower than the Browser's well optimized HTML parser.

Also, the slot tag does solve a minor problem of being the first tag whose out-of-the-box (browser CSS) behavior is `display: contents;`. It's obviously not a huge lift from the CSS one-liner, but there are still some uses for it even outside of templates.
by ChrisArchitect | 2025-09-03 17:24:04+00:00
At one time there was a whole promo website for this, https://web.archive.org/web/20200222091737/https://b612-font...

Some previous discussions:

2019: https://news.ycombinator.com/item?id=18946601

2023: https://news.ycombinator.com/item?id=37517567
by sarchertech | 2025-09-03 17:24:14+00:00
Imagine that when you deploy you have an LLM that regenerates code based on your specs, since code is fungible as long as it fits the spec.

Keeping in mind that I have seen hundreds to thousands of production errors in applications with very high coverage test suites?

How many production errors would you expect to see over 5 years of LLM deployments.
by xg15 | 2025-09-03 17:24:20+00:00
No, Python's system is more complex and unfortunately overloads "await" to do several things.

If you just do

async def myAsyncFunction(): ... await someOtherAsyncFunction() ...

then the call to someOtherAsyncFunction will not spawn any kind of task or delegate to the event loop at all - it will just execute someOtherAsyncFunction() within the task and event loop iteration that myAsyncFunction() is already running in. This is a major difference from JS.

If you just did

someOtherAsyncFunction()

without await, this would be a fire-and-forget call in JS, but in Python, it doesn't do anything. The statement creates a coroutine object for the someOtherAsyncFunction() call, but doesn't actually execute the call and instead just throws the object away again.

I think this is what triggers the "coroutine is not awaited" warning: It's not complaining about fire-and-forget being bad style, it's warning that your code probably doesn't do what you think it does.

The same pitfall is running things concurrently. In JS, you'd do:

task1 = asyncFunc1(); task2 = asyncFunc2(); await task1; await task2;

In Python, the functions will be run sequentially, in the await lines, not in the lines with the function calls.

To actually run things in parallel, you have to to

loop.create_task(asyncFunc())

or one of the related methods. The method will schedule a new task and return a future that you can await on, but don't have to. But that "await" would work completely differently from the previous awaits internally.
by rdtsc | 2025-09-03 17:25:01+00:00
> Nothing upper-middle class people love more than worshiping dead black Americans, while treating their descendants like dangerous parasites.

I know, right? It's those Dutch folks living in Bulgaria hating black American descendants again, eh? /s

So, to be serious, do you have evidence that Roelant Hollanderr is treating black American descendants as "dangerous parasites"? Those are pretty hefty accusations. I haven't found anything on their website, but I am sure you have some solid evidence somewhere.
by tomayac | 2025-09-03 17:25:24+00:00
[Author here] The AI feature is their implementation on the server. I was just trying to see if the same could be implemented client-side as a good use case for the, as you say, experimental, Prompt API. (It's in origin trial, so you can use it already on production sites.) Downloading a model for just this use case is obviously stretching it. You'd use it if it's there, but not download it on purpose just for this convenience.
by MobiusHorizons | 2025-09-03 17:26:10+00:00
I have never needed to write assembly in a professional context because of the changes you describe, but this does not mean I don't have a need to understand what is going on at that level of abstraction. I _have_ had occasion to look at disassembly in the process of debugging before, and it was important that I was not completely lost when I had to do this. You don't have to do something all the time for the capacity to do something to be useful. At the end of the day engineering is about choosing the correct tradeoffs given constraints, and in a professional environment, cost is almost always one of the constraints.
by antognini | 2025-09-03 17:26:36+00:00
The behavior of a random walk in a high dimensional space can be counter-intuitive. If you take the random walk trajectory and then perform principal components analysis on it, it turns out more than half of the variance is along a single direction. More than 80% is along the first two principal components.

To make matters even more surprising, if you project the random walk trajectory down into these PCA subspaces they are no longer random at all. Instead the trajectory traces a Lissajous curve. (For example see figure 1 of this paper: https://proceedings.neurips.cc/paper/2018/file/7a576629fef88...)
by tomrod | 2025-09-03 17:27:35+00:00
You'll need to specify the study, I see several candidates in my search, several that are quite older.

Generally, yes, low N is unequivocally worse than high N in supporting population-level claims, all else equal. With fewer participants or observations, a study has lower statistical power, meaning it is less able to detect true effects when they exist. This increases the likelihood of both Type II errors (failing to detect a real effect) and unstable effect size estimates. Small samples also tend to produce results that are more vulnerable to random variation, making findings harder to replicate and less generalizable to broader populations.

In contrast, high-N studies reduce sampling error, provide more precise estimates, and allow for more robust conclusions that are likely to hold across different contexts. This is why, in professional and academic settings, high-N studies are generally considered more credible and influential.

In summary, you really need a large effect size for low-N studies to be high quality.
by cnst | 2025-09-03 17:27:38+00:00
Nothing exists in a vacuum.

I'm not a fan of Chrome, or some of the choices they made for ChromeOS, but if they're willing to provide "proprietary" hardware APIs, that are fully documented and open-source, and can be used free of charge, and free of mandatory centralised control mechanisms like on iOS, then I'm all for it.

Mozilla had the opportunity to do the same with Firefox OS; but, of course, now they don't quite have the resources to do that anymore, so, instead they get to tell us that we cannot have nice things?
by SAI_Peregrinus | 2025-09-03 17:28:06+00:00
Lathes can make cylinders, but not of unlimited length in one setup so they lose some accuracy making cylinders longer than their carriage travel. And their beds are by necessity longer than their carriage travel, since the carriage rides along the bed and isn't infinitely thin. They also can't make things like motor stator laminations, and you definitely need a motor for a replica of a motorized lathe. So lathes can't replicate themselves exactly.

Milling machines are also just lathes with a different orientation, an extra travel axis, and a motor optimized for higher speeds & lower torques, it's possible (and reasonably common) to use a mill like a lathe or a lathe like a mill in many cases. So "only machine" part is also a stretch.
by ModernMech | 2025-09-03 17:28:17+00:00
It’s not that they embed probabilistic behavior per se. But more like they are chaotic systems, in that a slight change of input can drastically change the output. But ideally, good compiler design is idempotent — given the same input, the output should always be the same. If that were not generally true, programming would be much harder than it is.
by omneity | 2025-09-03 17:28:19+00:00
Here’s a quick sanity check before you embark on the real thing:

- Tokenize your entire corpus with a few off-the-shelf multilingual tokenizers like Llama, Qwen and Gemma and calculate the ratio of letters to tokens. The higher the better, ideally in the 3-5 range

- Manually produce or select sentences that are similar in meaning but not in writing (embedding models also leverage graphemic overlap not just semantic similarity), and then check if similar sentences show consistently higher cosine similarity than dissimilar sentences. This is for embedding models like XLM RoBERTa not for LLMs, but it has a similar insight potential.

If both of these tests are promising then you likely don’t need custom implementations for these.

Personally if I was you, I would just take Qwen 0.6B Base (not instruct, since you want text completion) and continue pretraining it on the data that you have. It is very likely to work decently out of the box.