But for (1, 2), just to point out, neither of your criteria would pass muster in the scientific communities who are ultimately responsible for vetting this work, right?

The ideal is: we don't accept papers at NeurIPS (or wherever) because of affiliation, and the badge of "quality" is bestowed by peer review, from other scientists.

> is of comparable quality (if not better than)

But the posts that you refer to in your own post point out several ways in which the quality is not good ...

But, in any case, I find it a bizarre choice to call it a paper when the authors themselves do not refer to it as such. We can agree to disagree, but just offering feedback.

It's a blog post which received feedback from collaborators.

It hasn't gone through the academic paper lifecycle ... the authors themselves refer to it as a post and as preliminary.

I feel like I'm taking crazy pills, but can we be precise when talking about work of this form? It started with referring to arXiv pre-prints as papers, and now we're at blog posts with an academic template as papers.

A paper is a fucking paper: something which has been vetted by the scientific community, with at least some form (often, a few rounds) of anonymous review from people outside your circle of collaborators

This is not there yet, and clearly so due to the various feedback from people (including the two pushback posts on HN) critiquing the lack of discussion about the existence of these techniques in mech interp, etc?

The binary is running. Maxwell is watching it: presumably there is some cost to the watching, but the LLM is not running in the binary process. Maxwell also has dynamic information about the running environment. Maxwell can then try and superoptimize the running binary using the dynamic information it has, but to do so, it needs to create semantics-preserving patches to the running binary.

What should be clear here: dynamic information is strictly more information than what a static AOT compiler has access to.

So that's the problem: we're going to patch the binary while it is running, and we need the patches to preserve the semantics as expressed by the high-level program, possibly assuming that the compiler was semantics preserving, etc. I'm assuming they have custom compilers or something for all of this.

Getting this to work probably involves creating some sort of source map, perhaps a custom linker, etc (just guessing) from high-level program to binary -- but assuming you handle all of that, then the job of Maxwell is just the job of a normal superoptimizer: propose semantics-preserving patches, see how they do, etc.

In theory, you could propose terrible patches frequently - superoptimization normally discards these, but you with bad proposals you might spend a long time searching for good patches. But LLMs are good proposers now, so you'd probably mostly get good patches (to a limit).

Authors, correct me if I'm wrong.

But people who write JITs don't call the overall process (original code, JIT) "self-improving code", do they?

What is the "self" in (original code, JIT)? Is it the entire process? But the JIT doesn't make itself better as it runs? Is all code that runs in a managed runtime with dynamic analysis self-improving?

A much better term might be "dynamically-improving code"

But related and to the point of my original message: the phrase "self-improving" has been used in vogue by AI research / labs ... and this is another example of something which is not a clear term, and seems intended for marketing

- verification

- superoptimization specialized to a particular piece of hardware

- patching binaries while they are running

all great

That being said, I'm getting some weird vibes from the prose on this site. Little phrases and claims that seem intended for the purposes of marketing, but conflate things with clear technical meaning in confusing ways.

For instance: I watched the video ("a code execution model has to be right every time") which implicitly communicates something like "the model cannot hallucinate" ... of course, the agentic LM is still probabilistic, but it is wrapped with verification tools (to reason about semantic equivalence), and is likely post-trained to be good at using those tools.

This strikes me as a conflation between the model and the harness which is intended to strike a marketing point (like: "it doesn't hallucinate") but which is clearly a ridiculous claim to make (falling down the slope: any harness which does error correction for improper tool calls might also be a "model which makes no mistakes")

Also: "self-improving code"

that's not really it, is it? Self-improving code would be code that runs itself and improves itself. This is code I run, which Maxwell watches and improves ... no?

Related: I dislike the usage of the word "model" in the above discussions on the site. Do we want to call everything a "model" now? Can anyone invent a new frontier "model" by post training an agentic LM with tools?

Also, let's say you are optimizing kernels on GPUs. This can be subtly fraught: for instance, it was well-known for awhile that one should only use certain pieces of software (vLLM, for instance) to reproduce papers (which used vLLM) there are non-deterministic sources of randomness (including, of course, floating point) that would prevent one from recovering the performance claimed in a paper ...

Also, not mentioned in my post:

- Mitchell Hashimoto

- Prime Intellect (and all their agent experiments)

- Geoff Huntley (see Jiti, for instance)

(many more)

There's a ton of interesting software being developed with these models by people outside the in group, but I find most of the software from these big guys to be ... bland. Buggy copies of copies.

Also, yes there are still bugs in Claude Code. I experience them nearly everyday.

It is markedly better than early days, but still not the best harness.

The best software written with agents seems to come from people outside of the labs (see pi, for instance — or all of cloudflare’s recent work)

Which makes me question either the model, or the holders …

Let's say, for the sake of argument, that the models are some multiplicative factor better on the inside.

Doesn't that mean the demos should work?

> The discourse around software engineering has gotten dumber. It’s like everyone in the industry lost 30 IQ points. People used to talk about compilers, type systems, logic. Now they talk about “prompts”, “harnesses”, “loops”. The discourse is narrower, shallower, and more repetitive. There’s only so many times I can hear about “agentic harnesses” before I lose my mind.

I agree with the frustration here :)

> You design a revolutionary new programming language: who cares? Maybe Claude cares, for what that’s worth. But humans don’t write or even read the code anymore. The programming language is an implementation detail the humans no longer have to care about.

Perhaps the people who weren't inclined to think about compilers, type systems, and logic before coding agents will never think about those things. If anything, I think about those systems significantly more now, because I view them as ways to describe the search space for the agent ... and perhaps, in the future, even tools to structure agentic latent representations.

So I propose rotating your viewport: yes, perhaps entertain the idea that it doesn't make sense to think about these things for human consumption ... but instead, what if we think of programming language and compiler design as being a tool to control the search space, and suddenly there's lots of new ways to think about these things.

Is this a valuable way to think? I'm not sure, but we should try and find out.

(For instance, 58 pages, 80 pages ... I don't think of these as normal academic length if this is the main body content ...)

I mean, I feel like I'm going crazy -- but I was struck by this jarring blending of experiences ... shitting out some growth plots followed by autopilot on your wedding. Nice OpenAI. The only thing missing is a moment of self-reflection where I contemplate where exactly I lost what makes me ... me.

Is this what SV wants the world to look like? Mixing fucking cake batter while a bot shows me a regression to the mean website? Pretending like I have any sort of intentionality in my life, while a nameless entity (given quirky form) sort of walks me through my life?

I'm not sure why it gave me this impression, but strikes me as vaguely reminiscent of soma (from Brave New World).

Kind of sad, because the tech is actually incredible: who are they hiring to storyboard these commercials?

If I'm wrong here, I'd love reference links. I think of these companies as trying to inspire the idea that Claude (or GPT) are these special alien entities, in a sense?

Here's my issue with this post:

> True to the spirit of the challenge, they didn’t use millions of dollars in computer power. They used Fable 5.1, working within Claude Science, a platform scientists can pay to use.

Okay, billions of dollars have been poured into these agentic LMs, right? Each training run to get the next increment is costing millions of dollars?

This feels like an obvious jab at Navier-Stokes, but where we get to shift the numbers around to hide where the compute actually is being spent ... compute is being spent. It's either being spent in amortization to make the search smarter ahead of time, during training, or its being spent after.

Also love: scientists get to pay Anthropic to work within their special science harness to do science. That's exactly what I dreamed of doing when I pursued physics in undergrad, one or two companies holding the keys to "progress" for a monthly subscription price.

It's sort of a litmus test for how little someone understands how learning in humans works or AI itself even. "Agentic" AI acts as a mirror: the more insight have yourself, the more powerfully you can pull the distribution ... the more you get out of it. (there's a bloodborne-inspired parable in here somewhere ...)

I think it's why the software from AI companies has "garbage" qualities. They are assuming that AI is going to fill in skills ... when it is a reflective amplifier.

But back to the discussion of "things we don't need to learn anymore": do we go to the gym, and say ... oh I don't need to do pull ups anymore, because there's an assisted pull up machine and I can just set it to my weight ...

Utterly idiotic.

- Use the code that your agents write in anger.

There you go. Do I know when my agents fuck up? Yes, I absolutely do -- because I'm a user of the code I have my agents write, and I ask things like "why is it taking 50 ms to start this program ..." and then I go in and find stupidity, and excise it. I do this over and over again.

Is it faster than writing it out by hand? Maybe! It's definitely a different perspective.

Start behaving like a baby "why, why, why" and then do a bit of reading, and you'll be fine.

A lot of these blog posts seem like they're aimed at software written by B2B companies who don't even use their own software ...