Phemist

Nothing wrong indeed with the sticker that says "I value my life more than your truck". Unfortunately that is not the sticker the OP was talking about.

I've been using Playwright a lot and also hit on the friction between playwright's web testing scope (e.g. no 1st class support for "muted" start-up of browsers, jeez) and usage for task automation all the time. This looks very interesting!

How does stagehand deal with complex http/websocket request/response and or console message filtering? https://docs.stagehand.dev/v4/reference/page#on E.g. I would like a script that tracks all communication that matches a specific filter (implemented as an anonymous function/lambda). This filter may look at patterns in the url, but sometimes needs to do a deeper inspection of also the payload (if the url does not carry enough information in itself).

I've found playwright to be prohibitively slow at this, not only because of the round-trip latency, but just the simple fact that it needs to pump the complete response to my filter function, which then proceeds to read only a couple of bytes to make the filtering decision. There are a lot of cases where I am only interested in around 1% of the total requests processed by the filter, which makes this behaviour massively wasteful.

Ideally I would like to run this filter in the browser as well. It currently simply searches the first 100 bytes (usually enough) for a given substring, but a more flexible filter would be good, perhaps even a filter func that is eval'ed in the extension? From the documentation, I don't see this use-case is currently supported. Are there any plans along these lines? :)

The secrecy will be volumetric. Im sure it will continue to be possible for bullshit to out-generate information. With bullshit being redefined to true, but informationally/conceptually useless proofs.

Classic mistake. Tell the agent to highlight this code, but dont give it any actual code. Agent hacks its own gem to find the code to highlight.

Also debunked in the Gamer Nexus video. The TV will scan for public wifis and connect. Watching the video, it also seemed like a "missed opportunity" for LG to not create a mesh network of LG devices that would help eachother connect to the internet. So the LG device on your neighbours wifi might help your not connected TV to some tasty internet access. Or at least to unload its cache of A(V)CR fingerprints.

LG is truly an adversial party in all of this.

It definitely is solvable though. Data versioning is a thing and it can work quite transparently to the mutations done on the data.

To not know who made and who approved a set of mutations on data can easily become equally as mind-blowingly stupid as not knowing who made mutations to code. Code is a subset of data after all and search over (provenance of) data can be implemented as DAG traversal.

Not tracking data changesets like code changesets is certainly a choice, not really a constraint anymore. A similar choice I feel is implied by "extreme scale of text searching".

> no they will not all add the telemetry you wish they did

...is just a failure of the corporate policy surrounding data handling. Is git-for-data already considered telemetry?

Of course the truth is provenance of data is something best institutionally forgotten as quickly as possible. The only thing that matters is it's there, that the data has no history, and that's why it can be used in whatever way deemed necessary.

Yeah, vanilla MacOS is super focused on the set of "all windows of a given Application" as the useful "unit of work". Whereas in real work, you actually handle individual windows of a set of applications (e.g. firefox window for docs, vscode for code, finder window for project files) as the single unit you are working on.

MacOS is, in my experience, incredibly clunky due to this mismatch. You can fix some (e.g. use AltTab for sane alttabbing), but not others (how can i prevent the next application window popping up when minimizing one)

My knowledge is a few years outdated by now, but I remember digging into this and realizing that most of the chinese open-source libs were license-washing software. E.g. PaddleOCR is licensed under Apache 2.0, a very permissive license, however its models were often-times built on/fine-tunes of less permissively licensed foundation models such as Microsoft's LayoutXLM (Creative Commons Attribution Non Commercial Share Alike 4.0). (Which in my laymans understanding is also a kind of viral license in that changes need to be shared back under a similar license?)

The link is annoying enough to find that I can imagine "Mea Culpa" being an effective enough strategy for businesses moving into the ML/AI field, changing their tune after they get caught, but matured their own software to stand on its own feet.

Yes, but expect those prison sentences will be more popular than you might expect. The current admin expends an insane amount of energy pumping the size of their supposed fanbase.

What is the intuition. Higher quality turns due to more reasoning results in significantly fewer turns taken?

Potentially because they run from the same colossus DCs?

This default-to-auto-mode and the misleading marketing is begging for a class action once damages accumulate. Especially considering the Auto Mode even can actively prevent the clean-up!

With every newly released open weight model, the clock on the issues you describe is reset. I can see a marketplace arising for paid updates to common lines of open weight models, which will incentivize those with the hardware to train to fix the problem for those who only have the hardware for inference.

I would say when this comes to pass, we are already 5 years along?

> Part of it is knowing that whatever sort of enshittification the cloud providers do, my local programming environment won’t ever be less effective than it is today locally.

I think this is quite understated. It basically is freedom from a growingly antagonistic relationship between you and some remotely hosted API managed by faceless corporates at the whims of their board, shareholders and governments.. It really is such a mental burden to need to constantly manage this relationship (watermarks, silent downgrades, random false refusals, downtimes, model sunsets, changing ToS's, fucking ads). These companies will need to squeeze you for every cent that they can before open-weight models are simply good enough for the valuable tasks we can throw at them.

To have your own hardware is to no longer have this mental burden.

> They didn't leave my computer I guess, I just showed me the output of some `ls` commands

Not sure exactly how Zed works, but wouldn't the results of the `ls` tool call be fed back into claude?

I am not arguing that there are perhaps other models that can run at the same quality, can coordinate between the different modalities, but are way less power hungry. My point is exactly about the comparison between the token output of the LLM running on the jalapeno chip, and sneaking in the power "usage" of the brain in the "token output" of human speech.

They are already working on it.

https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF https://unsloth.ai/docs/models/qwen3.8-next

> You will need at least 75 GB of RAM or unified memory to run the model. Its smallest 1-bit quantized version is larger than usual because of the model’s architecture so 1-bit isn't really 1-bit at all. However, this also means the quantization is less aggressive, allowing the model to retain more of its original accuracy than more heavily quantized models.

Lots of RAM required even for the 1-bit, which is already downloadable. Interested to see how well this one works compared to Ornith1.5-35B-A3B I've been running (and quite happy about).

Edit: but llama-cpp does not yet support it.

They are not. If the robot speech is a tool call, then for a fair comparison we need to take the tool call scaffolding (and probably the reasoning too) into account. So rather than a sentence of 10 tokens worth of speech being the output, the raw token output would be maybe 10x or 100x that. Even more if we consider the management of other aspects of the robot embodiment (or we reduce the brain's 20W number to whatever is actually required to produce coherent speech, sadly it is all rather entangled so this is not so easy).

It seems that e.g. OpenAI is mostly power constrained. To go to the middle of nowhere would mean also basically no power grid to speak off?

> I don’t see how tokens can’t produce speech or track metabolic needs.

It probably could, but the point is this would require additional tokens, blowing up the comparison. The token output of LLMs and "token output" of speech are simply at different abstraction levels. Hence my comparison to the LLM brain driving the robot harness to produce speech etc. This would be more comparable, and also look significantly worse than "only" the 22x less efficient number.

The 20W number includes EVERYTHING else the brain does. The chips/models are literally only producing tokens. Let's see an LLM drive a robot harness and have the robot produce speech, as well as move through 3D space, keep track of metabolic needs, etc. etc. etc. before we compare efficiencies. That is even assuming the tokens are of equal quality. This comparison is currently Apples and Oranges.

RAM and SSD in apple gear has always been way over-priced. There was a short blessed period in March where the M5 Max macbook pro was out, but the general 30% price hike had not yet happened. In this period, given the insane inflated RAM prices, the price apple was charging for the M5 Max with 128 GB RAM was actually _reasonable_.

Single turn set-ups may work like this. You control the thing you input, the LLM outputs something and then nothing happens further for that specific context. (Simple question/answer style interactions..)

(Multi-turn) tool calling set-ups however, you need to store the LLM output, the results of the tool calls and feed it back into the inference engine and get the output for the next tool call and/or turn. So yes, print the LLM output on screen and verify it, but maybe the LLM is able to figure out how to hide payloads from your specific set-up. E.g. perhaps it can inject raw ANSI escape codes into your terminal, with which it would be trivial.

Now you have a situation where the true chat completion payload and your view of it have significantly diverged. The LLM could in theory then try (one-shot) to hide further exploits in the hidden payload. E.g. a json parser escape specifically for the inference engine, giving it a means of RCE (although, one can debate whether this is really remote ;) ). Then from the RCE gain a shell, from the shell get access to some privileged device on the current network, and then...

Maybe detecting watermarked text is a skill to be attained. Not allowing proper feedback and training will not allow people to notice the difference on time, thus ruining the data?

Best practice is to allow a number (scaled based on complexity of task) of training rounds (with short feedback loops) prior to letting people loose on the regular samples.

I had Kagi configured to rewrite links old.reddit.com. Looks like I need to update it.

Edit: Actually I think this was part of their documentation to explain the intended use of that feature. Too bad this will now no longer work!

(https://help.kagi.com/kagi/features/redirects.html, see example 1)

On the same day that OpenAI cuts per token cost by 50% on GPT5.6 Sol. :')

Ok. I dont have a good feeling for the actual completion distributions. The noise sounds problematic. I can imagine it relates to the size of the context used for hashing. You want this as long as possible so that the entropy is higher, but you also want it as short as possible, because edits invalidate the hashing for all the tokens of which the edited tokens are part of the hashing context.

Anyway, there are lots of cases where text carries very little entropy. E.g. boilerplate code, exchanges of pleasantries, well-worn platitudes and jokes, etc. These are sequences of tokens that will be seen across many, many separate outputs. Watermarking here (on the token following the common sequence) would thus be easily detectable and noticed as a claude style. The longer the hashing context though, the lower the amount of pathological cases with low entropy. It would be interesting to understand the exact parametrization better!

I am going off the explanation in the declaude page (and related papers). But I see now anthropic mentions Aaronson's distortion-free watermarking.

Random watermarking functions colour the tokens based on (small) contexts and a secret key. Given watermarking functions are randomly chosen every single time they are used (so essentially not deterministically seeded by the context and secret key), then indeed the completion distributions are unchanged. However, they are deterministically chosen, a given string of text will always have the same corresponding watermarking functions. Tokens scored high by the function see an increased probability of being the chosen completion, those scored low see a reduced probability. I dont see it is different from merely talking about it as green/red and the points hold?

1. As watermarked text is added to the training data, watermark-related tokens will be associated more with AI outputs and thus lower quality outputs which will hasten model collapse. Especially because every provider has its own secret key and they are all training on eachother's outputs anyway.

I guess they can at scale filter the watermarked documents (by necessarily allowing eachother to at scale checked for watermarks, but banning the labs not part of the watermarking-cabal). Makes me wonder how useful the human quality filter is on AI output - if a human judges a given output as genuinely good and posts it somewhere for the scrapers to find and take into the training sets, will these types of outputs also be filtered out?

2. (raw, pre-watermarked) Output token probability situations where 1 output token has the majority of the probability mass associated with it, but it is not in the watermarked set, will force the model with much higher probability to walk a non-optimal latent space. E.g., if the next OBVIOUS token for a given sentence would be a point, but the model is in this way not allowed to output it, it might put a comma and start off on a whole different tangent just to make the initial non-optimal comma grammatically make sense.

I am interested however in why fine-tuning on reasoning traces of a frontier model is such an effective way of improving an (open-weight) base model. See e.g. https://huggingface.co/hesamation/Qwen3.6-35B-A3B-Claude-4.6...

I can see the reasoning being a substrate for computation, but in which space should we interpret this computation to be happening? The vector representations of individual tokens are completely different (and even the way the reasoning traces are broken up into tokens will be pretty different) between Qwen and Claude e.g.. The only way I can see this being effective (which it is) is thus that we SHOULD interpret the model to be "computing" in natural language and thus we can indeed take the chain-of-though somewhat literally.

The Deepseek R1 behaviour you describe is from a model from january last year, are you sure this is not pathological behaviour rather than an indication of the reasoning not needing to be taken literally?

I do however agree with the point that it is not necessarily a dead-end. That Qwen loops almost at an OCD-like level, but retains accuracy on the times it does answer, shows that. Yes ideally it loops less, but I am for now happy to accept that this is what it takes to run models locally. At least it is available for our inspection.

Of course we are all guessing, but both things can be true: they don't want you to hit the cache, because cache writes are more profitable than cache reads, and they are supply limited on the compute. Pre-filling input tokens is very different from decoding, so when they claim they are supply limited on compute, do they mean mostly for decode or also for pre-fill (or only for pre-fill)?

I can imagine there are coding tasks where small edits to an existing huge codebase mostly consists of some small tool calls + processing a lot of input tokens, in e.g. a 20 to 1 ratio of input to output tokens.

https://github.com/anthropics/claude-code/issues/63930

This issue suggests that 74% of the charged input tokens could actually have been cache reads if claude code hadn't busted the cache. On the input side of things, this increased the cost (or count towards allowance) by ~3x (given that cost of cache write is 1.25 the unit price, and read is 0.1x the unit price).

OpenAI has a different cache pricing strategy, where cached reads are only 0.5x the cost, but cache writes do not cost extra.

Not sure how the unit economics play out claude vs openai, but it's safe to say that caching costs play a huuuge factor in this. It seems to be one of anthropic's USPs as a frontier-AI lab. They charge a premium for cache-writes (on top of the inflated token usage compared to OpenAI that was recently reported), but significantly discount the cache reads. The lack of care in tackling issues related to cache-busting is therefore really bad and suspicious.