comex

Correct.

I'm skeptical that this particular task would get blocked, though I could be wrong. But I agree that the moat is a problem in the general case.

Presumably yes. It is safe to assume that algorithms running the model changed, the training procedures changed, and the scale changed. Unfortunately the AI companies refuse to disclose the details of any of this, which is a harm to human knowledge (hopefully a temporary one). Yet the results speak for themselves.

For me it's only been in the last month with Opus 5.5 that I've been seeing code quality I actually respect (though this is with substantial human effort in the loop). Though this experience is from work where I don't have access to non-Anthropic models, nor Fable.

I agree, with respect to the status quo where AI writing is associated with lower quality.

In the long term, AI writing - mostly done solo, not directed by humans - will likely have higher quality than human writing, while being better suited to people's tastes since it can be personalized for every reader. If so, it's not hard to imagine it crowding out human writing.

You might ask, though, is that a bad thing? If it's legitimately higher quality, then what's wrong with consuming it? Well, I don't know. It certainly seems dangerous for everyone to be in their own little bubble of content. Social media of course tries to do that today, but there are limits. You can't pick any topic, any set of attitudes you want and get an infinite supply of content tailored exactly for you. Even if you find some super niche community to set up shop in, it's still a community; you're still exposed to the outside world at least a little. What happens when that changes?

It can’t, because passkeys are bound to specific domains and you simply aren’t given the option to log in with a passkey on the wrong domain.

At least on iOS it’s any app that implements the protocol. That includes Bitwarden, which is server-based but self-hostable. In the future it should also include apps like Strongbox and KeePassium which store the private keys directly in a portable .kdbx file.

I’ve run into this issue multiple times, no custom hardware involved. Just virtual machines that didn’t support Bluetooth, and physically distant computers I was controlling remotely.

You don’t have to use a password manager that relies on an account. Personally I use Strongbox on iOS and macOS, which stores everything (including passkeys) in a .kdbx file. I then sync the .kdbx file over iCloud, but if I lost access to iCloud then there would still be copies of the file on all my devices. Overall this is not as secure as the more centralized alternatives, but it does leave me in control.

Though obnoxiously, the public computer login method doesn’t rely solely on the QR code it shows, but also uses Bluetooth. So if you want to log in on a VM or computer without Bluetooth, or a physically distant computer being accessed remotely, you have no choice but to install your password manager on that computer. Which is a lot less secure than copying a single password and one-time code.

The OpenWrt One is really not a great piece of hardware. No 6GHz, and only two Ethernet ports, one of which is only 1Gbit. The latest GL.iNet products are apparently better, but also apparently don't run stock OpenWrt, only a fork of it. In other words, there's still plenty of room in the market for good routers with open-source firmware.

I know how to flash firmware, but I'd still rather buy routers that have open-source firmware pre-flashed and tested by the vendor. This is simply because I've often run into issues with OpenWrt. I once bought a bunch of Archer C7s because it was described as a good router for OpenWrt, only to discover dmesg full of crashes from the proprietary wireless firmware running on the 5Ghz chip. In another case, I learned long after installing OpenWrt that the performance was much worse than stock firmware because OpenWrt didn't support hardware routing offload.

It's vibecoded - new, large codebases are par for the course.

(This used to come at the cost of code quality, but increasingly does not.)

It's unclear how big a role distillation plays, but it may be a big one. There's also a law of diminishing returns. To get a meaningful increase in model quality you seemingly need an exponentially larger model. And most people don't think K3 is actually on par with top closed models.

Many of those utilities, if you inspect the source code, are recognizably the same programs as their original versions written 30+ years ago. They’ve been maintained and changed over the years, sure, but they’ve rarely needed big changes. After all, they’re simple programs that do basically the same job today as they did then, using basically the same API surface.

The main issue with this is that the programs are usually still single-threaded. For some key utilities like find and grep, this has allowed more modern alternatives to leapfrog them in performance. (To be fair, it’s hard to add parallelism without breaking compatibility somewhat.)

But in most other respects, there’s nothing wrong with being a little old-fashioned. Using global variables is an example of that. It’s a problem in larger programs but at this scale it’s fine.

That doesn't really make a difference, as TCC permissions don't care if you're root or not.

Yes, and macOS entitlements work similarly, as you know. I was interpreting “what it expects its children should be able to do” as a single rule for all child processes, like in OpenBSD pledge() which the parent seems to be referring to. Sure, such a rule could securely be greater than the parent’s own permissions if you strictly limit what processes can be executed with what arguments.

Actually, there’s another exception to my previous statement that I should have mentioned. For mitigations that are meant to prevent an attacker from turning memory corruption into code execution or code-execution-like control – such as restrictions on mapping memory executable (at least that’s one purpose for such restrictions), or memory map lockdown – the mitigations’ effectiveness doesn’t depend on whether they’re applied to children. Those mitigations are sometimes treated as part of the sandbox system, sometimes separate.

The backup apps I'm familiar with read files directly; they don't use asr.

If asr can be used to bypass FDA then that is just a security vulnerability.

Yes. Sandboxed apps do get their own home directories (~/Library/Containers/.../Data) and this home directory does contain a Documents directory, but this is just for compatibility's sake – there is no reason to actually use it for anything. Files that an app saves by itself are typically expected to be stored under Library/Application Support or Library/Caches, and this is still true even for a sandboxed home directory. Documents is reserved for files the user saves manually, but as mentioned, manually-saved files should reach the real ~/Documents.

Though, there is also a third type of Documents directory, the kind located at paths such as ~/Library/Mobile Documents/com~apple~TextEdit/Documents. This is part of iCloud Drive and is the same directory that you get in Finder by going to iCloud Drive -> TextEdit. Very confusing.

The latter does need to be a subset of the former, or else an attacker can trivially work around limitations on "what it should be able to do" by spawning a child instead of doing the thing directly.

But yes, it's unfortunate that macOS sandboxes cannot be nested.

I notice that

    Syncthing-For
    k

is one of the first pieces of text in the first screenshot. With the k on its own line like that. Not usually something I’d comment on, but if you’re showing off a redesign…

It’s a very common tic of recent Claude models specifically. Don’t worry - for better or worse, the labs are trying to train away AI writing smells (for example, Anthropic talked about Fable 5.1 having more natural writing), so this particular tic will probably become outdated as an AI indicator relatively soon, as em dashes already have. And then people will forget about it.

For me (Plus plan, iOS app), Astra only shows up under the Work tab.

I’ve been using Work for all my queries, since it seems to just be the same interface as Chat but with more features. I don’t understand why they’re two separate things.

(March 2026)

> The "toy model" part is flat out wrong, the models they use have _exactly_ fundamental mechanics then chatGPT or claude, they are used all the time for this kind of research for a reason.

Tiny models are sometimes used out of necessity, but the results often don't hold up at scale, or in different scenarios.

If you train a tiny transformer to use a fraction of its capacity to perform an algorithm simple enough that you could design the transformer weights by hand, the results might generalize to natural-language reasoning, but they easily might just not.

So it is hard to generalize even to something like GPT-3. But once you get to a modern LLM, the nature of the chain of thought is also very different.

First of all, the CoT can be very long and encode reasoning with long chains of serial dependencies. Filler tokens don’t increase the limit on serial computation, particularly in the dots example where the output is a single token (as opposed to real language model which can somewhat substitute for missing CoT by reasoning within the answer itself).

Also, a modern LLM gains much of its reasoning capability in post-training, where it learns which CoT tokens to emit rather than just relying on pre-existing chains of thought in its training data. The post-training involves reinforcement learning where the grader ignores the CoT and only grades the final result. The only things tying the CoT to natural language are (1) the starting point (pre-training data) containing natural-language CoT, and (2) the CoT being produced using the same weights as the final output. On one hand this could potentially make the CoT less faithful to the model's reasoning, since nothing directly punishes the model for, say, coming up with its own private meanings for words within the CoT. But on the other hand, this incentivizes the model to make good use of the CoT. To the extent that the CoT is a "parallel construction" (i.e. a chain of reasoning that has to be coherent-looking but differs from how the model is actually coming up with the answer), coming up with this duplicate reasoning is both a waste of computation and a big opportunity cost. The model should learn to instead use the CoT tokens for information that will be useful to it later. But in practice models do keep producing readable CoT, suggesting that the CoT does reflect the real thinking process to a significant extent (probably more so after post-training than before).

The dots paper has no post-training, so it doesn’t encounter this dynamic at all.

I'm not even an LLM researcher. But I believe you're correct; I just don't think the paper provides any meaningful evidence on the subject. From the structure of the model we can tell that dots can do more computation than no CoT and less than full CoT. What we don't know is how much of the performance gap between no CoT and full CoT would be recovered by an LLM using dots. The paper answers that question for a tiny transformer, but it's so different from an LLM that extrapolating to LLM scale is purely speculative. In other words it doesn't give us more information then what we can already determine from the structure of the model.

For the record, the original claim was that "you can replace intermediate tokens with single character chains and still get the increased precision", which I read as saying you can get almost all of the benefit of CoT with dots, not just some unknown fraction of it. This claim is true for the paper, though probably only because the benchmark was saturated (and training difficulty was also higher, as they mention). But the claim is unlikely to be true for LLMs, if only because they presumably do sometimes need to perform "long running calculations", and they also have plenty of unsaturated benchmarks.

(The other part of the original claim, that CoT is "not a representation of a model’s logical path", is more complicated. It's clearly not guaranteed to match the model's logical path, as we have seen with other research into actual LLMs. But it does seem to be correlated with it, presumably more so for more complex / long-running tasks.)

The model they use in that paper is a toy model of an LLM that’s so different from an actual LLM that I doubt the results mean anything at all.

Specifically, they train a model from scratch. The model architecture is apparently based on Llama but the size is 34M parameters. Not 34B, 34M. This is a fraction of the size of GPT-2.

Luckily, they don’t use the model as a language model. It neither receives text, generates text, nor uses text to think. Instead the inputs are strings like “A01 B10 C73 D27”, and the only possible outputs are “True” and “False”. They are expecting the model to solve a specific math problem encoded by those numbers, and do nothing else. The chain of thought is also numbers, in the scenario that’s supposed to represent a real chain of thought (as opposed to the filler-token scenario and the no-CoT scenario). The numbers in question are manually trained into the model based on one possible algorithmic decomposition of the problem; the model does not learn to generate its own CoT.

Even with all those limitations, for their main problem (3SUM), they only show that filler tokens are better than no CoT at all. They don’t show how that compares to ‘real’ CoT, at least as far as I can see (admittedly I only skimmed). They do make this comparison for their easier problem (2SUM), but on that problem both filler token CoT and ‘real’ CoT are mostly saturated, so the results don’t mean much.

Fable 5.1 apparently changes this policy.

Too bad. I see the stereotypical prose as a good thing. When I interact with Claude myself, I don’t mind it as it just feels like Claude’s distinctive voice. But when other people try to disguise LLM output as their own thoughts, the voice makes it easier for me to tell.

> Built on GTK, Relm4 runs on bare metal with no additional runtime in between.

So, not native in the sense of using or even resembling the native UI toolkit.

My experience is that even Opus 5 still tends to write buggy or low-quality code and makes serious mistakes when analyzing code. It's a lot better than before but still not something I trust. I've had less experience with Fable since I can't use it at work; I hear it's a step up but still has its limits.

For large tasks like a web browser or a compiler, even expensive swarms of frontier LLMs have not been shown capable of producing codebases that actually work. (Anthropic built a C compiler with Opus 4.6 but it lacked optimizations and apparently hit a complexity wall.)

I also want to use LLMs for reverse engineering, but apparently it's pretty hit-or-miss, especially if you're forced to use open-source models to avoid restrictions.