Revenue is just an agreement between friends.

LARP pairs you with another founder. You send them $10,000. They send you $10,000 right back. You've both now booked $10,000 in revenue. The books balance. Cash never moves. Everybody's a rocketship.

So basically PuzzleMoE is a new way to compress Mixture of Experts models without degrading their performance. The big problem with MoE is that it takes up a ton of memory because you have to store all the expert weights even though only a few are used at a time. Old methods like dropping or merging experts would just nuke the model's accuracy, but PuzzleMoE's trick is to do fine grained element wise merging by figuring out which individual weights are important and which ones are redundant across experts to merge them smartly.

Then a bit packing scheme stuffs the mask and sign data into the unused exponent bits of the Bfloat16 format since MoE weights don't use the full exponent range anyway. This lets inference run without any extra memory overhead making the whole thing fast.

This approach beats other compression methods by up to 16.7% on MMLU at 50% compression while having up to 1.8x faster inference. Pretty neat stuff.

DSpark by Deepseek. Huge speed and throughput unlock.

Paper: DSpark: Confidence-Scheduled Speculative Decoding with Semi-Autoregressive Generation

A developer used Claude Code (Fable 5) to add native iOS/iPadOS support and engine fixes to a GPL v3 port of Command & Conquer Generals: Zero Hour. Here's what Fable actually did, what it didn't, and why the HN thread argued about the title.

A 2003 real-time strategy game running natively on an iPad, with touch controls and no emulation layer, is the kind of project that reliably tops Hacker News. Command & Conquer Generals: Zero Hour did exactly that in early July 2026 — but the more interesting story is in the repo's commit history and the argument that followed about how much of the credit belongs to the AI.

If you're weighing whether Claude's Fable model is worth using for a legacy-code project of your own, this one is a useful, honestly-reported case study rather than a marketing anecdote.

I wanted to share a desktop client I've been building: DWN.BRIDGE (fully open-source C# WPF).

I love using AI for data analysis (like cleaning CSVs or querying databases), but there was no way I was going to upload my private/corporate files to cloud LLMs.

So I built a Zero-Knowledge local bridge:

• When you point the client to a local database (SQL Server, SQLite, Excel, CSV), the client extracts ONLY the table schemas/headers locally.
• It sends the schema metadata to the LLM (Gemini web UI) via a secure browser-automation bridge.
• The LLM writes the SQL query, and the client executes it locally on your computer. Your raw rows and records never leave your hard drive.
• All local file system access and system commands run locally and require explicit pop-up confirmation.

You can check out the source code or download the installer below. I'd love to get feedback on the local sandboxing model!

🔗 GitHub: https://github.com/MarckDWN/DWN.BRIDGE

Turns out that token embeddings in smaller language models collapse into a narrow cone as they pass through transformer layers which reduces their representation expressivity. And the effect is much more servere in smaller models than larger ones. So one of the reasons larger models outperform smaller ones is due to having better organization of latent representations. Good news is that you can use a training objective that spreads embeddings uniformly across the representation space to counter the problem which means smaller models could be a lot more capable.

A new paper challenges how post training is typically handled. Usually, what happens is that the entire model is updated during reinforcement learning based on the assumption that all the weights contribute roughly equally to the new capabilities. The authors of this paper decided to freeze the whole network and apply RL to just one single transformer layer at a time. What they found is that training a single layer can capture almost all the performance gains you would get from a full parameter update. In several cases across different model sizes, training a single layer actually outperformed updating the entire model. They tested this phenomenon on models ranging from 1.5B to 8B parameters using algorithms like GRPO across math and agentic tasks.

And the most interesting part is where these highly effective layers are located within the architecture. Turns out that there is a very consistent structural pattern where the highest contribution layers are clustered right in the middle of the transformer stack. Meanwhile the layers near the input and output ends contribute significantly less to the final RL improvements and the layer rankings stayed stable even when they evaluated fundamentally different tasks like mathematical reasoning versus code generation.

All this means that we can make training both cheaper and more effective by freezing the lower contribution layers and only training the top performing middle layers, which consistently beats the standard full parameter training baselines. Even a simple heuristic approach where you blindly select a block of middle layers without doing any prior profiling turns out to work better than updating the entire network.

Another really neat finding is that training different single layers results in models that end up solving completely different subsets of problems. If you take seven models trained on seven different individual layers and run a majority vote, the overall performance easily beats a standard self consistency ensemble generated from a single fully trained model. This heavily suggests that different layers naturally gravitate toward distinct types of reasoning strategies during the RL phase.

cross-posted from: https://lemmy.world/post/48190865

A very very senior game developer recently told me how he is changing specialization because AI is much better than him at what he does already.

I asked him if it was just the speed and mass of code, to which he replied that Claude 5 Fable/Mythos is just so advanced, it comes up with solutions he would never have thought of, not even requiring good prompts anymore.

He further said in some areas like Unity it's not perfect yet, but improving drastically.

Honestly this is pretty different to what I read in many articles regarding AI code.

They mentioned errors, bad performance & such.

However if it is already used in production and he as a professional evaluating it, is saying it's better than him...

That same day I also talked to somebody that got hired to train an LLM. His interview was with that companies chatbot, that offered him over 120$ per hour, a roughly 500% increase from his previous job 🤣

A new paper from Moonshot AI tackles a key bottleneck in how language models handle depth. Standard residual connections just add up the outputs of all previous layers using fixed uniform weights, and uniform addition creates a problem where hidden states grow uncontrollably as the network gets deeper. As a result, the contributions of early layers end up getting completely buried and diluted by the time the data reaches the end of the model.

This happens to be the exact same issue older recurrent neural networks faced over time before attention mechanisms came along. Naturally, they tackle the problem in a similar way using attention residuals instead of a fixed accumulation and applying a softmax attention mechanism over the outputs of preceding layers. Now, every single layer gets a learned pseudo query vector that lets it selectively pick and choose which earlier representations it actually needs to look at. This allows the network to naturally retrieve information from anywhere in its depth depending on the specific input.

However, applying this over every individual layer is called Full AttnRes and it comes with a massive catch which is that saving all those individual layer outputs creates memory and communication bottlenecks during large scale distributed training because the overhead scales linearly with the number of layers. So, in order to make the architecture actually usable they grouped the layers into chunks and summed up the outputs inside each block. The cross layer attention is then only applied over these compressed block level summaries rather than every single layer drastically reducing the memory and communication footprint.

By combining a block structure with a smart cross stage caching system and a two phase computation strategy the setup becomes a practical drop in replacement with practically zero training overhead. Their experimental results show that the performance boost holds up consistently across different model sizes.

cross-posted from: https://lemmy.world/post/47499598

We’ll soon get a chance to see whether, frankly, our last hope, evil corp Google, can still distinguish content created by AI from Human one 🤖

Here’s how I would rank the detection difficulty: 1️⃣ Text 2️⃣ Code 3️⃣ Images 4️⃣ Gifs 5️⃣ Videos If they already fail at level 5, we have a SERIOUS problem.

cross-posted from: https://sopuli.xyz/post/46320128

Literally speaking, there's some truth to Olah's musing. AI systems are not cold – Blackwell chips idle at 32 to 38°C. They are not calculating – they're bad at math. And they're not robots – AI models are specialized binary blobs of tensors and metadata that can be instantiated across multiple servers.

But the notion that there's some AI mystery in the spiritual sense is just hot garbage. 

AI systems are indeed "made from us, from our words" and that is why Anthropic and its rivals have been named in more than 100 lawsuits. One of the reasons those systems remain mysterious is that Anthropic and its rivals don't disclose where they got their training data.