mccoyb

Right, makes sense — yes, all good questions that I’d also like to understand the answers to.

I think you're misunderstanding the premise.

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.

I agree with you that Maxwell is like a JIT (with superoptimization inside of it: a very smart one which can propose smart things using the underlying agentic model, and reason about semantic equivalences to figure out what to commit or not) and that that is a natural analogy.

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

Let me say that I like the idea:

- 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 ...

No, I’m talking about the recent DevDay.

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 …

If the software coming out of OpenAI and Anthropic is what we have to judge, I wonder about the 5000 ...

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?

There's several things I disagree with in this post (a matter of perspective, I think):

> 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.

Call me crazy, but if you can't explain the idea in 10 pages or less, you don't understand the idea.

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

Are you against accessing hardware that you own?

I love these commercials where someone has chosen to show how the AI product will essentially be used to slop out some garbage piece of corpo communication ... and the user basically says "looks good" with barely any thought, then mixed with some sort of real life thing (wedding planning here).

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?

How do you know that "we" in "we do not use facial recognition technology" covers ambient.ai, who presumably gets the feeds directly?

Agree with you, but not sure what form the arms race will take as the months go by (between harness engineering, RLing models within harnesses, etc)

Oh I agree with you! I just don't see "we're standing on the shoulders of giants" in most of these marketing blog posts?

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?