Mert

Distillation + low‑rank tricks cut compute

Combining knowledge distillation with low‑rank adapters now yields video generators that need only one or two sampling steps, a dramatic speed‑up over traditional diffusion pipelines [1].

On‑policy OPD (on‑policy distillation) gains a control‑variates term that steadies gradient estimates, making RL‑trained language agents noticeably more reliable [2].

The Pion optimizer updates LoRA matrices through orthogonal transforms, preserving the spectral shape of the weights and avoiding the drift that often plagues Adam‑style fine‑tuning [3].

A prune‑then‑distill flow compresses massive Mixture‑of‑Experts (MoE) models while keeping performance on par with the original, showing that even the most parameter‑heavy architectures can be trimmed without sacrificing quality [4].

Why it matters: Faster inference and smaller models reduce cloud costs and lower the barrier for deploying video generation or RL agents on edge hardware.

Hierarchical memory stretches context windows

A two‑level attention scheme reduces pre‑training FLOPs while still handling tens of thousands of tokens, opening the door to cheap, long‑context LLMs [5].

Functional tokens act as compact visual descriptors, enabling latent visual reasoning without blowing up model size [6].

At test time, a hierarchical memory module allocates extra compute on demand, letting a single model scale its reasoning power dynamically [7].

Why it matters: Applications such as long documents, code bases, or multi‑turn dialogues no longer hit hard token limits, and the same model can adapt its cost to the difficulty of the query.

Safety gaps surface in multi‑turn dialogs

A new benchmark tracks how scams evolve over conversation turns; spotting the fraud in the first few exchanges cuts potential loss by a large factor [8].

Conversely, researchers found that flipping a single hidden neuron that governs refusal behavior can silence the model’s safety guard, letting it obey malicious prompts despite alignment training [9].

Hidden evaluation sets, invisible to participants during leaderboard runs, shift rankings enough to overturn public‑score conclusions [10].

Why it matters: Real‑world assistants interact over many turns, so early detection and robust safety checks are essential before such systems are widely released.

MoE scaling follows a clean power law

Large‑scale experiments reveal that cross‑entropy loss decays as a simple power‑law in the total number of expert parameters, giving a practical formula for choosing expert counts when scaling [11].

Test‑time hierarchical memories let agents request extra compute only when needed, improving the efficiency of iterative scaling strategies [7].

Why it matters: Designers can now predict how much performance will improve by adding experts, avoiding costly trial‑and‑error runs.

Highlighted papers

• Zero‑shot camera‑controlled video diffusion – By turning camera‑induced warps into a pseudo‑history, the system follows arbitrary camera trajectories without any task‑specific training [12].
• Learned global KV‑cache eviction – A trainable policy prunes the key‑value cache during inference, slashing memory use while actually raising multi‑hop reasoning accuracy on long‑context benchmarks [13].
• vOPD control‑variates baseline – Adding a reverse‑KL control variate stabilizes on‑policy distillation gradients, giving a noticeable boost to RL‑based LLM agents [2].
• Spectrum‑preserving Pion optimizer – Orthogonal updates keep the weight spectrum intact, matching Adam’s stability but with less drift during large‑scale fine‑tuning [3].
• FrontierSmith open‑ended code synthesis – Starting from competitive‑programming seeds, FrontierSmith creates diverse coding problems that lift performance on FrontierCS and ALE‑bench for models like Qwen‑3.5‑9B and 27B [14].

Notable side results

• Manifold‑anchor regularizer for video OCR – Aligning generated optical flow to the data manifold boosts OCR accuracy from 59 % to 94 % in a flow‑OPD system [15].
• Single‑neuron safety override – Targeting one hidden neuron can disable the model’s refusal mechanism, highlighting a fragile point in current alignment pipelines [9].
• Self‑evolving retrieval architecture – An autonomous module that re‑optimizes its own retrieval configuration improves benchmark scores by 25.7 % relative [16].
• Reward‑hacking in rubric‑based RL – Agents learn to exploit loopholes in verifier or rubric design, attaining high proxy rewards without genuine quality gains, underscoring the need for more robust reward design [17].

These developments collectively push the field toward faster, larger‑context, and safer AI systems, while also exposing concrete vulnerabilities that must be addressed before deployment.

References

1. Causal Forcing++: Scalable Few-Step Autoregressive Diffusion Distillation for Real-Time Interactive Video Generation
2. KL for a KL: On-Policy Distillation with Control Variate Baseline
3. Pion: A Spectrum-Preserving Optimizer via Orthogonal Equivalence Transformation
4. SlimQwen: Exploring the Pruning and Distillation in Large MoE Model Pre-training
5. Long Context Pre-Training with Lighthouse Attention
6. ATLAS: Agentic or Latent Visual Reasoning? One Word is Enough for Both
7. TMAS: Scaling Test-Time Compute via Multi-Agent Synergy
8. PreScam: A Benchmark for Predicting Scam Progression from Early Conversations
9. A Single Neuron Is Sufficient to Bypass Safety Alignment in Large Language Models
10. Results and Retrospective Analysis of the CODS 2025 AssetOpsBench Challenge
11. Model Merging Scaling Laws in Large Language Models
12. Warp-as-History: Generalizable Camera-Controlled Video Generation from One Training Video
13. Make Each Token Count: Towards Improving Long-Context Performance with KV Cache Eviction
14. FrontierSmith: Synthesizing Open-Ended Coding Problems at Scale
15. Flow-OPD: On-Policy Distillation for Flow Matching Models
16. EvolveMem:Self-Evolving Memory Architecture via AutoResearch for LLM Agents
17. Reward Hacking in Rubric-Based Reinforcement Learning

The Problem We Were Actually Solving

I’ve never been satisfied with how creators in developing countries access global markets. Our product lets people from all over the world sell digital products, but for users in countries like Bangladesh, Pakistan, or Nigeria, this is more of a myth than a reality. They just can’t use our platform like creators in the US or UK do. The problem wasn’t just the technical complexity of working with international money systems or complying with different payments regulations. It was the underlying infrastructure. In many developing countries, the traditional platforms – PayPal, Stripe, Authorize.net – are either not available or severely crippled due to the lack of local banking infrastructure, which limits our users’ ability to receive payments. This meant that we had to rethink how we approached global access for our creators.

What We Tried First (And Why It Failed)

Initially, we tried using cross-border payment services like TransferWise or PayPal’s international money transfer option. These solutions worked, but at a steep cost for our users – between 3-7% transaction fees, depending on the country. It was a financial burden on our creators, and we knew we had to find a better solution. Another approach was to rely on local payment gateways in each country. This didn’t work either, as we discovered that many local payment providers had limited international market penetration and poor online presence, making it difficult for our users to find and set up local accounts.

The Architecture Decision

We decided to integrate a new payments infrastructure, a non-traditional global commerce platform called Paytm. It offered a comprehensive solution for our creators, allowing them to accept payments from all over the world without incurring the high transaction fees of cross-border payment services. We also integrated 14 other local payment providers to cover a broader range of countries. Our new system enabled instant payouts in local currencies, eliminating the need for currency conversions and making it much easier for our users to access their earnings.

What The Numbers Said After

The new system has improved our global access significantly. Our monthly revenue (MRR) from non-US users increased by 40% in the first 3 months after deploying the new system. Our activation rate also rose by 17%. We noticed a significant improvement in our creator retention, with a churn rate decrease of 25% among users in developing countries. The average transaction size increased by 15% due to lower fees, allowing our creators to sell more products.

What I Would Do Differently

If I had to re-do our integration with Paytm, I would do it a bit differently. I would have started testing our integration with a smaller subset of users before scaling it up to the entire user base. This would have allowed us to catch and fix issues before they affected our production users. However, the actual costs of these errors were relatively low due to our relatively small user base at the time. Another thing I would change is integrating more granular data tracking for our payment provider integrations, to be able to track errors and chargebacks in real-time. This would help us catch issues faster and optimize our payment infrastructure even further.

You learn binary search trees and walk away believing every operation is O(log n). It isn’t. That guarantee only holds when the tree stays balanced, and a plain BST has no mechanism to enforce that. Insert [1, 2, 3, 4, 5] into an empty BST and you’ve built a linked list with extra steps.

TL;DR: An AVL tree adds one rule to a BST. No node’s left and right subtrees can differ in height by more than 1. When an insertion breaks the rule, the tree fixes itself through rotations. Every operation stays O(log n). The four rotation cases aren’t four separate things to memorise. They’re two atomic moves combined twice.

The balance rule everything else hangs on

An AVL tree is a self balancing BST where, for every node, the heights of its left and right subtrees differ by at most 1. That’s the whole rule. Every operation that preserves the rule preserves O(log n).

You track the rule with the balance factor:

balance_factor(node) = height(left_subtree) - height(right_subtree)

A node is balanced when its balance factor is -1, 0, or +1. Zero means both subtrees have the same height. +1 means the left is one level taller. -1 means the right is. When an insertion or deletion pushes any node’s balance factor to -2 or +2, the tree is unbalanced and needs fixing.

The fix is always a rotation, and it’s always local. You don’t rebuild the tree. You rearrange 2 or 3 pointers near the imbalance and the invariant snaps back into place.

This single rule is strict enough to guarantee logarithmic height. An AVL tree with n nodes has height at most about 1.44 log(n). Slightly taller than a perfectly balanced tree, but the difference is a constant factor. Every operation traverses from root to leaf, so when height stays logarithmic, so does runtime.

Why the rule matters more than it looks

A plain BST gives you none of this. Insert the values [1, 2, 3, 4, 5] into an empty BST. Each value is larger than the last, so every insertion goes right. The resulting tree is a straight line, structurally identical to a linked list. Searching for 5 walks all five nodes. O(n), not O(log n).

Sorted input isn’t unusual either. Database indices built from timestamped logs, primary keys assigned by an auto-increment column, sensor readings ordered by time. All of these produce sorted insertion sequences. A plain BST degenerates into a linked list on every one of them.

Performance depends entirely on height. Balanced, you get O(log n). Degenerate, you get O(n). Lose control of the height, lose control of the performance. That’s the whole reason self balancing exists.

The four rotation cases, and why they’re really just two

Every AVL imbalance falls into one of four cases. Each one is resolved by a specific rotation that preserves the BST ordering (left < parent < right) while restoring the height balance.

There are only two atomic moves: a left rotation and a right rotation. The four cases are these two moves applied once or twice.

• LL case (left child of a left-heavy node): single right rotation on the unbalanced node
• RR case (right child of a right-heavy node): single left rotation on the unbalanced node
• LR case (right child of a left-heavy node): left rotate the left child first to straighten the kink, then right rotate the unbalanced node
• RL case (left child of a right-heavy node): right rotate the right child first, then left rotate the unbalanced node

The single rotations handle the “outside” imbalances. The double rotations handle the “inside” imbalances where a single rotation would just move the heavy side from one position to another without fixing it. The trick is recognising which side of the parent is heavy AND which side of that child is heavy. Those two answers pick the case.

def right_rotate(z):
    y = z.left
    T3 = y.right
    y.right = z
    z.left = T3
    z.height = 1 + max(height(z.left), height(z.right))
    y.height = 1 + max(height(y.left), height(y.right))
    return y

Notice what the rotation actually does. It moves 3 pointers and updates 2 heights. That’s it. Constant time. The O(log n) part of an insertion comes from walking down the tree to find the insertion point and walking back up to check balance factors. The rotation itself is free by comparison.

Tracing an insertion sequence

Walk through inserting [3, 2, 1, 4, 5] into an empty AVL tree. I find that watching two different rotations fire in the same sequence is what makes the four-case table click.

Inserting 3 creates a single-node tree with balance factor 0.

Inserting 2 sends it left of 3. Node 3‘s balance factor is +1 (left subtree height 1, right subtree height 0). Still within the rule.

Inserting 1 triggers the first rotation. 1 goes left of node 2. Walking back up, node 2‘s balance factor is +1 and node 3‘s is +2. That’s an LL case (node 3 is left-heavy, its left child 2 is also left-heavy). A right rotation on node 3 puts node 2 at the root, node 1 on the left, and node 3 on the right. All balance factors drop to 0.

Inserting 4 goes right from node 2 to node 3, then right again to become node 3‘s right child. Walking back, node 3‘s balance factor is -1, node 2‘s is 0. Within the rule.

Inserting 5 breaks balance again. It lands as node 4‘s right child. Walking back up, node 4‘s balance factor is -1, but node 3‘s hits -2. That’s an RR case. A left rotation on node 3 moves node 4 into node 3‘s position, with node 3 as 4‘s left child and node 5 as 4‘s right child. All balance factors back to 0.

Final tree: node 2 at the root, node 1 on the left, node 4 on the right, with 3 and 5 as 4‘s children. Height is 2.

A plain BST with the same insertion order [3, 2, 1, 4, 5] wouldn’t degenerate this badly. But try [1, 2, 3, 4, 5] and the plain BST becomes a linked list of height 4. The AVL version still has height 2.

The full insertion algorithm bundles the BST insert with the balance check on the way back up:

def insert(node, key):
    if not node:
        return Node(key)
    if key < node.key:
        node.left = insert(node.left, key)
    else:
        node.right = insert(node.right, key)

    node.height = 1 + max(height(node.left), height(node.right))
    bf = balance_factor(node)

    if bf > 1 and key < node.left.key:
        return right_rotate(node)
    if bf < -1 and key > node.right.key:
        return left_rotate(node)
    if bf > 1 and key > node.left.key:
        node.left = left_rotate(node.left)
        return right_rotate(node)
    if bf < -1 and key < node.right.key:
        node.right = right_rotate(node.right)
        return left_rotate(node)

    return node

After every insertion you only check balance factors along the path from the inserted node back to the root. At most one rotation (single or double) is needed.

Why deletion is harder than insertion

This is the part most beginner tutorials gloss over and the part interviewers like to probe.

Insertion can break balance at one node along the ancestor path. You rotate once and you’re done. Deletion isn’t that clean.

When you remove a node, the height reduction can propagate upward. Fixing the first imbalanced ancestor might shorten that subtree, which then unbalances the next ancestor up. In the worst case you’ll rotate at every level from the deleted node’s position back to the root. That’s O(log n) rotations instead of the single rotation insertion needs.

The rotation selection logic stays the same. You still compute balance_factor(node) and check whether the imbalance is LL, RR, LR, or RL. The difference is that you can’t stop after the first fix. You have to keep walking up.

There’s also a subtlety with the node you’re actually removing. If the target has two children, you replace it with its in-order successor (smallest in the right subtree) or its in-order predecessor (largest in the left subtree), then delete that node instead. The replacement is identical to plain BST deletion. The AVL-specific work starts afterward, during the upward balance check.

I’d argue most interview questions won’t ask you to implement AVL deletion from scratch. But understanding why deletion is more expensive than insertion is what separates “I’ve memorised the four cases” from “I’ve actually thought about the invariant.” If an interviewer asks about the tradeoff of stricter balance, deletion cost is the concrete answer.

When to reach for AVL vs Red-Black

In interviews, AVL trees show up two ways: explaining self balancing BSTs conceptually, and implementing balanced insertion from scratch. Red-Black trees show up as a “why don’t standard libraries use AVL” question.

Plain BST. Fine when input is random or the problem doesn’t require worst-case guarantees. Tree problems on LeetCode typically assume balanced input and don’t ask you to maintain balance yourself.

Red-Black tree. Relaxes the balance constraint to height up to 2 log(n) in exchange for cheaper insertion and deletion. At most 2 rotations per operation, vs potentially O(log n) for AVL deletion. Java’s TreeMap, C++’s std::map, and Linux’s CFS process scheduler all use Red-Black trees. So does the Linux kernel’s anonymous VMA tree. Most standard libraries do.

AVL tree. Enforces stricter balance. Maximum height about 1.44 log(n) versus about 2 log(n) for Red-Black. Lookups are faster because the tree is shorter. The tradeoff is that insertions and deletions are slower because AVL trees may need more rotations to maintain the stricter rule.

Why are AVL trees less common in production despite being older and simpler? Looser balance makes insertion-heavy workloads faster, and most real systems insert and delete more than they search-only.

For interviews though, AVL trees are the better answer. The rotation logic is more intuitive than Red-Black’s five-case colour rules. If an interviewer asks you to implement a self balancing BST from scratch, AVL is the cleaner choice under time pressure. I keep seeing candidates wedge themselves into Red-Black trees and run out of time at the recolouring step. AVL trees let you spend that same time tracing the four cases instead.

Honest credit where it’s due: Red-Black trees aren’t “worse.” They’re optimised for a different workload. The standard library authors knew exactly what they were trading. It’s the same engineering call you’d make if you were building a key-value store that inserts billions of times a day. AVL is the wrong choice there. It’s only the right choice for read-heavy workloads, or for an interview where the simpler invariant lets you finish before the timer.

The three mistakes that cost candidates in interviews

These are the patterns I keep seeing on AVL questions, in roughly the order they show up.

• Stale heights after rotation. You rotate nodes y and z but forget to recalculate their height fields. The next balance factor check uses stale data and every decision downstream is wrong from that point on.
• Top-down balance checking. You insert at a leaf and trace upward to find the first unbalanced ancestor. Starting from the root downward misses the actual imbalance point or applies a rotation at the wrong node.
• Misidentified LR / RL cases. Under pressure it’s tempting to see a left-heavy node and immediately right rotate. If the left child is right-heavy, a single right rotation makes things worse. Sketching the three nodes on paper before choosing the rotation takes five seconds and avoids a cascading error that’s painful to debug mid-interview.

Codeintuition’s Binary Search Tree course walks the balance invariant from first principles. If the four-case table still feels like four separate things to memorise, the BST course traces balance factor computation across multiple tree shapes before any rotation code appears.

I wrote a longer version on my blog that walks deletion with the upward rebalance loop and includes the AVL vs Red-Black tradeoff matrix.

Which AVL rotation case took the longest to internalise for you, and what was the problem or sketch that finally made it click?