Jakaline

T2I Diffusion / LLM Researcher / WebDev /
My sides won't stop killing me - I mean my side projects

[Jakaline @Jakaline_dev]

https://t.co/J29JzbxMt4
WIP LLM server built with llama-cpp-python and Litserve. You can create and add your own samplers. Check out to test newer samplers such as DRY or XTC.

[donald @donaldjewkes]

I made this with one prompt using Opus 5.5

I spoke to my computer for 5mins, claude worked for 12 hours, and I woke up to this

full prompt:

[soyukke @soyukke_game]

opus 5.5はAGIだわ....

[Ostris @ostrisai]

I decided to have fun this weekend and train my own image diffusion model from scratch. Training on a single local GPU. This is 2 days in. It is a purely experimental arch that is working surprisingly well for its size and how it works.

There is no text encoder. I am using the qwen3 tokenizer and dumping those token embeddings straight in next to image tokens with a time 0. Only self attention.

It is pixel space. I am just doing patch 16 straight into the transformer. I am not doing any projection layers. The hidden size is 768 so the blocks work directly on the pixels not a projected image embedding.

There were visible patches, but I added a shuffler to fix it. It does an alternating unpatching, mirror padding 8 on all sides and then re patching so the cross seams land in the center of patches, runs through a block, then depatch, crop and repatch every other block. It cleaned up immediately when I added it, something only possible without projection.

There is no VAE, no text encoder, and it is tiny and super fast. Really tiny. It is 441 million parameters total. 116 (1/4) of those is the token embedding table. To put that in perspective, SD 1.5 was 983 million (te and unet)

Will it be able to make coherent images? Not sure. I will keep training it for a bit though to find out. It seems to be understanding the basic concept of the prompts and if you squint really hard, it kind of looks like the other AITK samples with the same prompts.

[NovelAI @novelaiofficial]

[Image Generation Model Release] NovelAI Diffusion V5 is here!
Over twice the size of V4.5, with an updated dataset and a custom 32-channel VAE for overall improved image detail. Compose scenes with far more characters than any previous version, plus full multi-panel comics. Now with official Japanese support and improved prompt understanding.

[Ameilo @Ameilo_1]

参照画像なしのMiniMax H3。
やはり良い！
日本語もミスなくいけてる😆

[Wildminder @wildmindai]

MiniMax-H3 Looping Sketch Anime LoRA.

for looping anime-style sketches

https://t.co/VCdq2jhCMr

[Lorn @lorneseth]

Japan is about to test an officially licensed RPG that changes according to what the player says.

RyzaChat lets you tell its heroine to gather materials, craft a weapon, fight a monster, camp by a lake or build an entire hot-spring town.

The AI decides how each instruction unfolds and keeps track of inventory, stamina, currency and progress.

SpiralAI and Gust launch it in Japan on August 18 for iOS and Android.

If it works, every major game publisher will want a character that never runs out of quests.

[Hanwen Jiang @hanwenjiang1]

Interested in how frontier labs pre-train image/video generation models?
We were too.

Since those recipes are rarely made public in full, we started from the most mature pretraining playbook available in the open: how modern LLMs are built.
Introducing Chimera: a visual generation model family that brings LLM-style hybrid linear attention and scaling co-design to visual generation.

In large-scale pretraining, nearly every design choice eventually shows up.
That means solving architecture design and scaling as one coupled problem: every architectural choice changes how the model scales, and scaling behavior determines which choices actually survive.
Chimera approaches both jointly, building a model family that remains predictable as model size, compute budget, and data distribution change.

Our key architectural observation is a simple division of labor: a single raster-ordered KDA stream carries long-range state, while modality-aware short convolutions preserve native local geometry.
Together, they form an effective and elegant linear-attention backbone for multidimensional visual data, with periodic MLA providing direct global interaction and sparse MoE expanding capacity at controlled activated compute.

This design comes with a useful effect: NoPE.
In Chimera, position is represented by the computation itself. KDA’s ordered recurrence and learned state decay encode order and recency, while the short convolutions encode local spatial-temporal structure.
Explicit positional embeddings are not needed in our design.
Because these mechanisms are not tied to a fixed training grid or sequence length, Chimera shows strong zero-shot extrapolation in both space and time.
Trained exclusively on 1K images and 5-second videos, it directly generates coherent 4K images with little visible quality degradation and 30-second videos with only 6.5% FID degradation over the final five seconds, all zero-shot, without resolution- or length-specific finetuning.

But architecture alone is not a pretraining recipe unless it scales predictably.
Thus, scaling should not be treated as an afterthought: fitting a curve over model sizes is easy; making that curve meaningful is much harder.
If every model size is differently under-tuned, your scaling law may simply be measuring optimization error.
We propose HeteroP to transfer proxy-tuned hyperparameters module by module across width and depth, giving us a consistently tuned model family. This allows us to fit Chinchilla-style laws over activated model size, training tokens, and the image-video data mixture.

The laws not only provide the reference for compute-optimal model and data size, but also suggest that visual generation may be more model-hungry than we tend to assume.
Under the same parametric loss-fitting method used in Chinchilla, compute-optimal model size grows as FLOPs^0.516 for images, compared with FLOPs^0.46 for language. Video is even more model-hungry, with the exponent rising from 0.516 for images to 0.544 for video.
Guided by these laws, we trained an 11B-parameter Chimera that activates only 2B parameters per token, using ~600 H100 days.
- It matches Wan-2.1 2B pretraining loss with 7.3x fewer FLOPs, and runs 2.14x faster than full attention at 255K tokens.
- It matches FLUX.1-dev and Z-Image-Turbo on GenEval and outperforms both on DPG-Bench, using roughly 20× less training compute than Z-Image-Turbo.

Ultimately, Chimera indicates that once you pretrain at scale, every decision shows up.
And if the Kimi K3 recipe caught your attention, Chimera may look oddly familiar, except the tokens are pixels and frames with diffusion models.

A team effort from team @ChongjianG30781 , me, @VisionSteve , Jiuxiang Gu, @Xu_Arthas , @chenziwee , @ShaotengLiu , @Jingorz , @YicongHong , @Zefan_Cai , @HaoTan5 ; supported by Hailin Jin and @kalyank_s at @Adobe @AdobeResearch

[Bad theory labs @Badtheorylabs]

Today we are Introducing BTL-3.

A 27B open-weight agent model built for agentic coding, structural tool use . The complete thing fits in one 8.39GB file under 2.5 bits per parameter smaller than an 8B model in fp16, and retains 92.2% of the 27B itelligence

BTL-3 is trained for the loop real agents live in: reason, act, inspect the result, recover, continue. It handles single, sequential, and parallel tool calls and knows when the right move is no tool call at all.

HumanEval: 95.12% pass@1
BFCL v4 AST: 88.5% (full 1,240-case set)
Multiple tool calls: 95.5%
Tool-call abstention: 91.2%
262K context architecture

Two editions, both open today.

BTL-3 is the maximum-quality checkpoint, for Transformers and vLLM.

BTL-3 Compact is the entire model in one standalone 8.39GB GGUF. No base download. No reconstruction. One file, one command, a running agent.

Compressing 27B this far normally destroys a model. Standard quantization couldn't do it, so we built the stack ourselves: packed AVQ2 decoder tensors, affine INT4, measured precision islands, packed vocabulary matrices, rank-32 output correction, behavioral repair. 2,416 tensors byte-verified at export.

Then we tested whether the agent survived. On a fresh sealed 100-turn tool-contract gate, Compact retained 92.2% of teacher-correct behavior 100% on single, parallel, sequential, and abstention calls.

43 tok/s generation on an RTX PRO 6000. Fully local. Nothing leaves your machine.

BTL-3: https://t.co/ddZWWr6i3o
Compact: https://t.co/6URHEBGJgG
Runtime + source: https://t.co/MjXQR6koKt
Apache-2.0 model. MIT runtime.

[青龍聖者 @bdsqlsz]

Flux3，omni model！

[Jakaline @Jakaline_dev]

Somehow, Gemini 3.6 Flash passed the vibe check. Barely. But it gives great hope for awaiting Gemini 3.5 Pro.

[alex zhang @a1zhang]

Transformers struggle to generalize to tasks they were not explicitly trained on. Instead, we propose in 2026 that it is the job of the harness to generalize through composition.

We observe a powerful property when training RLMs: for tasks with shared structure that look different, the root model naturally learns the same trajectory, meaning it views the two task trajectories as the same! In other words, the Transformer does not need additional generalization capabilities to transfer capabilities from one task to the other, the harness induces it.

We find that well-designed harnesses form a quotient set over task trajectories, meaning their individual LLM calls can see structurally “similar” tasks as near-identical, token-for-token! Harnesses can effectively generalize for the Transformer during training, without relying on any intrinsic generalization capability from the model.

For example, RLMs can see problems of different lengths as the same: we show that RLMs can train exclusively on short tasks, and fully generalize to similar but unseen tasks 8-32x longer because it produces near identical trajectories for both.

Taking this further, we show that tasks across different domains (e.g. math solutions vs. essay writing) that share a decomposition strategy exhibit the same generalization effect. RLMs can train on the problem of finding which essays belong to the same author and improve performance on finding math problems that share similar solutions.

The full blogpost, experiments, and discussion are in the thread below.

[Jakaline @Jakaline_dev]

I will never get larpers calling Kimi K3 beating Fable or whatever, until weights are open and other providers give options that reduce thinking, this thing is unusable

[Ruoyu Feng @ruoyu_feng]

🚀We released SeFi-Image, an open-sourced, more compute-efficient text-to-image foundation model.

✅Code and weights:
GitHub: https://t.co/SDyH2XkUUJ
Project Page: https://t.co/BdwfVw2GrS
Hugging Face: https://t.co/T25LpvcI1N

[ali(gnment) @waterloo_intern]

we distilled 2.3M Claude Fable 5 reasoning traces into Qwen3-4B

- 100% self-consistency @ 512 samples
- 0.00 bits output entropy
- zero hallucination variance

turns out the student is not bounded by the teacher.
it also converged on one universal truth.

we open-sourced the model weights👇

[Sakana AI @SakanaAILabs]

Excited to share our paper, “Learning Multi-Agent Coordination via Sheaf-ADMM” to be presented at #ICML2026

Blog: https://t.co/F5CVepgivO

Most AI models process information as one giant, monolithic block. But in nature, intelligence often comes from a group of individuals working together, where each individual only has a limited view of the world.

We built a framework called Sheaf-ADMM to study how this kind of collective problem-solving works. We divide a complex task into smaller overlapping pieces, and assign one agent to each piece.

To solve the global puzzle, the agents negotiate in three simple steps:

1. Local Guesses: Every agent looks at its limited view and proposes a solution.

2. Finding Common Ground: Agents communicate with their direct neighbors to smooth out conflicts. They do not need to agree on everything, but they must agree on the boundaries where their tasks overlap.

3. Remembering Disagreements: If neighbors cannot agree, they keep a memory of that conflict. This memory forces them to try harder to compromise in the next round.

We tested this on problems where no single agent has enough information to succeed alone:

• Multi-Agent Sudoku: Each agent sees only a single row, column, or 3x3 box. The framework achieved a 93% solve rate, while a parameter-matched message-passing baseline scored 11%.

• Image Classification: When we tested canvas-size domain shifts, a standard CNN dropped to 11% accuracy on MNIST, while our method retained 86%.

• Maze Pathfinding: Sheaf-ADMM matches a message-passing baseline’s accuracy while agents communicate over a 5-dimensional channel, 8x smaller than that required of the baseline (42).

Traditional message-passing networks hide their reasoning inside opaque hidden states. Our framework makes coordination completely transparent. You can watch exactly how local agents debate, compromise, and eventually reach a global consensus.

Sheaf-ADMM draws inspiration from two fields with long histories in distributed consensus: ADMM from distributed optimization, and sheaves from applied topology. We think these perspectives may offer insights for the distributed, multi-agent AI systems increasingly being built today.

Read our full paper: https://t.co/RoOHfekjQE
Code: https://t.co/KDKZRcbuQH

[Gill @gurtej__gill_]

The Kimi Team wrote a really clever paper back in March that fixes a fundamental flaw we have sort of just accepted in Transformer design: “Uniform Residual Connections”.

Right now, we blindly add every layer’s output together with the exact same weight and it completely dilutes early layer features as the networks get deeper.

Their Paper “Attention Residuals” (AttnRes) replaces that rigid addition with softmax attention over the depth dimension.

It lets each layer dynamically look back and grab only the specific earlier representations it actually needs.

To keep the memory from exploding at scale, they designed "Block AttnRes" which you can see in the paper.

It groups layers into blocks so the attention step runs only across those macro levels.

They actually pre-trained this on 1.4 trillion tokens using a 48B parameter Kimi Linear model and it completely stabilized hidden state growth while giving a massive boost to heavy reasoning tasks.

It's a great reminder that tweaking how the information flows through a network can be way more powerful than just throwing more compute at it.

Read the full paper here:
https://t.co/XaGXIHxs1c

[Lukas Kuhn @lukaskuhn77]

🔥 We introduce LeVLJEPA: the first fully non-contrastive end-to-end vision-language pretraining method competitive with CLIP & SigLIP ����🏼

👀 No negatives. No temperature. No momentum encoder. No teacher-student.

TL;DR: LeVLJEPA learns image to text structure by prediction: each modality predicts the other's embedding, while SIGReg keeps each embedding isotropic Gaussian. 🧵

📄 https://t.co/1qBXor8qTf

[Jakaline @Jakaline_dev]

Most of this claim is irrelevant because open-source Chinese models exist. You just aren't appreciating it enough

[Alex Finn @AlexFinn]

AI subscriptions are dead

Claude Fable 5 will only be on the Anthropic subscription until June 22nd. After that, you will need to pay for usage per token

This will be the start of a much larger trend

Frontier models will no longer be included in subs

You’ll pay a fee and it will only get you access to older, much cheaper models

If you want access to that dank AI sour diesel, you’re going to need to pay for every token you use. No more subsidies

And it make sense. The subsidies were just a Ponzi scheme

For those that don’t know, when you pay $200 a month for an AI sub, you get thousands of dollars of tokens

These AI companies actively lose tremendous amounts of money because of these subscriptions. GDPs of most countries every year are lost on your $200 Claude Max sub

The investor money is running dry. IPOs are coming because of this. And with IPOs need to come profitability

The golden age of paying $200 a month and being able to code on 40 Claude Code instances and getting a usage reset every 5 minutes are about to die

The party couldn’t continue ever. You can’t just leverage the entire global economy for years and expect nothing to break. Now it’s time to pay up

Means a few things:

1. Time to be responsible when it comes to which models you use. You don’t need Fable 5 for GPT 5.5 Xhigh for everything. Build the skill of knowing when to use cheap models

2. Local LLMS/hardware will come even more in demand. I’m currently running GLM on my Mac Studio. It’s great. Is it Fable? No. But it gets the job done for free on simple tasks. Learn about local LLMs

3. This is the beginning of the wealth gap expansion. Those that can afford to spend $10,000 a month on Fable 5 will build incredible products that eat up more and more of the economy. Those that can’t afford Fable 5 will have an insane disadvantage

4. The government will need to step in eventually. There will be too much civil unrest. I hope the answer isn’t free money. That won’t do anything. I hope the answer is education/access to AI resources for ALL. Universal Basic Opportunity

5. You need to seriously reconsider where your money goes every month. If you are complaining about AI prices and in the back of your mind you know your skill set is becoming quickly irrelevant, all while spending money every month on Netflix, Xbox Live, Paramount +, drugs, DoorDash, Uber, and other things that bring nothing positive to your life, you are simply doing it wrong. AI is an investment in yourself. It’s an investment in your relevance to the global economy. You need to make sure you make that investment

The pieces on the board are quickly moving around. The rules are changing. The battlefield is shifting. If you’re not strategizing accordingly, you’re cooked.

[Jakaline @Jakaline_dev]

BTW I don't play BA...