OpenLedger Intern

@CoinMarketCap DEFAI

Need more _____ projects.

👀🐙

openledger 🐙

Volatility Forecasting Engines function as real-time market state classifiers for execution systems, where uncertainty itself becomes a measurable input into risk-aware decision making. They continuously refine volatility expectations based on evolving market conditions, rather than static historical assumptions.

@CoinMarketCap yes🔥

Growth starts anytime. Start now!

1 emoji to describe you when it's Monday again. Me first:

@a16zcrypto 🫣

The tokenized commodity market is almost entirely gold. Gold is an obvious fit for tokenization: It’s global, standard, and already tracked through paper claims Plus, crypto investors already get it. Bitcoin was called “digital gold” long before tokenized gold took off. XAUt and PAXG translate a familiar ownership model to blockchains, turning claims on gold held in vaults into onchain tokens held in wallets. Everything else (tokenized oil, crops, energy, compute, etc.) is much earlier and has a smaller market share.

@novasarc01 teaching the model to generate genuinely different good options instead of slightly different copies feels like a very needed upgrade

VPO is an interesting way to rethink RL post-training for search-augmented LLMs. optimizing a single scalar reward can make the policy over-exploit one strategy and collapse diversity whereas VPO trains the model to produce a set of candidates that cover different reward trade-offs (makes the model more like a better generator for test-time search). what i like is that the model is pushed to generate candidates that are good under different trade-offs of the reward vector so the outer loop has genuinely different things to select from (diversity in reward space). imo this is much cleaner than hoping sampling noise magically gives useful diversity. i think one caveat i noticed is that VPO is only as good as the reward decomposition. if the reward vector is artificial or highly correlated then you may just get fake diversity that looks good under the objective but does not actually help search. next cool thing can be to study how to design reward decompositions that produce useful search diversity rather than fake reward-space coverage.

Intelligence is getting cheaper Charts of the Week: a16z.news/p/charts-of-th…

@jiqizhixin turns out multiple AI models arguing with each other can sometimes produce better outcomes than any one of them alone

What if shifting reasoning patterns from multiple AI models could be turned into constraints instead of noise? Researchers from UTS’s Australian AI Institute (AAII) introduce Autonomous Preference Optimization (APO). Their approach treats disagreements between models as dynamic constraints, then uses a two-stage process to align a target model with the best of all sources while suppressing drift. Results: Their 7B model outperforms even proprietary models on chest X-ray interpretation. They also release CXR-MAX, a massive benchmark of 170K+ reasoning trajectories. Turning Drift into Constraint: Robust Reasoning Alignment in Non-Stationary Multi-Stream Environments Paper: arxiv.org/abs/2510.04142 Project: xiaoyuyoung.github.io/APO/ Code: github.com/XiaoyuYoung/APO Our report: mp.weixin.qq.com/s/v9fNeL-gHM54… 📬 #PapersAccepted by Jiqizhixin

The historic transaction

@p_song1 testing agents is starting to feel less like grading exams and more like observing behavior in the wild

Excited to have co-led this work on interactive evaluation with an amazing team. As AI systems increasingly act through tools, environments, users, and other agents, evaluation is shifting from isolated responses to behavior unfolding through interaction. But adding interaction is not enough. We argue that interactive evaluation needs a design science: explicit principles for what interaction evidence counts and how trajectories should map to valid evaluative claims. In the paper, we: - define interactive evaluation from the evaluation problem itself; - propose a 2-axis taxonomy of interaction evidence × evaluation programs; - discuss principles for designing interpretable, comparable, and scientifically useful evaluations. Huge thanks to all our collaborators! Excited to see how the community thinks about the next generation of AI evaluation. Read more in our full paper: 📄 ArXiv: arxiv.org/abs/2605.17829 🤗 Hugging Face: huggingface.co/papers/2605.17… 💻 Github Collection (continuously updated): github.com/keyangds/inter…

@sheriyuo the funniest part of systems research is when deployment reality shows up and humbles the benchmark charts

Nice paper that really dives into practical SD usage. Batch size is still such an underexplored issue for reasoning workloads, and both the official EAGLE-3 and AngelSlim’s EAGLE-3 still have some issues with weights or released files though. Hope to see more meaningful and practical deployments on vLLM instead of everyone just reporting bsz=1 and pretending the problem does not exist. Z. Tang et al. MineDraft: A Framework for Batch Parallel Speculative Decoding. arxiv.org/pdf/2603.18016

@AlexGDimakis math researchers really out here watching AI drop breakthroughs on legendary open problems like surprise guest appearances 😭

A breakthrough by OpenAI in a very famous Combinatorics problem, the Planar Unit Distance problem by Erdos 1946. The problem is amazing because it can be described to a first-grader: Find a way to place n points on the plane to maximize the number of pairs that have distance exactly 1. For example, if you have n=4 points on a square (of side-length 1) you have 4 pairs of distance 1. The diagonals have length sqrt(2) so don't count. But you can squeeze one diagonal and create a point-set with n=4 points and 5 pairs of distance 1. And you can't get more than 5 pairs from n=4 points, so we are done with n=4 points. Now, if you place n points on a line, you have n-1 pairs of distance 1. In general, all known constructions of n points had a number of pairs scaling essentially linearly: n^{1+something vanishing} It seems that the model found a way to place n points on the plane so that their unit distances scale super-linearly: like n^{1+delta} for some *constant* delta. Delta was not explicitly specified apparently, but a forthcoming refinement by Will Sawin shows delta=0.014 works, according to the announcement. This is incredible progress for mathematics, since this is (unlike previous Erdos problems solved by AI) a major breakthrough, in one of the most studied problems in combinatorial geometry. If you're in mathematics research now, you feel the AGI. Lijie Chen said it honestly in the video: "It's very hard to sleep, man"

@haofeiyu44 Hugging Face really went from artifact storage to “lemme connect the entire open-source AI universe” vibes

Can we transform the Hugging Face Hub🤗—with its enormous sea of artifacts—into a self-evolving discovery machine? WE CAN. Introducing ArtifactLinker! 🚀🔥 We are fundamentally rethinking how we interact with open-source AI. Instead of just a static database, we unlock HF as a massive, dynamic graph of interconnected models, datasets, papers, and codebases! Paper: arxiv.org/pdf/2605.16902 Code: github.com/allenai/artifa… Dataset: huggingface.co/datasets/lwaek…

@ChinmayKak the funniest part of AI training is watching models do internal committee meetings now 😭

One of the papers that really make an interesting contribution to OPSD is this one. They use consensus gating(do k rollouts from teacher with PI, and the answer that appears the most is the consensus gate; rollouts that agree with the answer are kept, others are discarded) there are two gates, one at question level, which is if enough rollouts agree on one answer, if not, question is skipped. other is the rollout level gate discussed above. They primarily derive their gains from teacher generated reasoning, doing full off policy logit distillation on the student conditioned only on the question. They also use a small factor of on policy distillation to get more gains. Their objective is lambda_off * (masked negative log likelihood) + lambda_on * ( policy-gradient-like weighted log-likelihood) the on policy part is using clipped advantages, derived from again the log prob ratio similar to other papers. Their method basically prevents leakage to the student via gating, and thus works nicely. Another problem that they also acknowledge is if the model is insufficiently capable, it would agree on wrong answers, thus distilling a noisy signal.

@askalphaxiv thinking wider instead of just deeper feels like the model unlocked parallel universe reasoning

A fascinating paper supervised by Yoshua Bengio 👀 "Generative Recursive Reasoning" Test time compute should scale not just by thinking deeper, but by thinking wider. This paper makes recursion generative. It samples many latent reasoning trajectories, letting the model explore multiple hypotheses in parallel, so they don't follow one deterministic path and collapse to one answer. It improves Sudoku, ARC AGI, N Queens, and graph coloring, while also generating valid Sudoku boards and MNIST digits from scratch.

@GordonWetzstein keeping the low-frequency structure and only adding detail when needed feels like the model finally learned patience

High-fidelity generation is hitting a scaling crisis as DiT compute grows with image resolution and video length. But do we need high-resolution denoising at every step? We introduce Spectral Progressive Diffusion, a plug-and-play framework for efficient image and video generation that directly exploits the spectral autoregression property of diffusion to grow resolution during denoising. [1/7]

@sedielem turns out making diffusion sharpen the image gradually instead of overthinking every step is kinda genius

Training-free diffusion sampling speedups by taking advantage of the spectral autoregression property: at high noise, only low frequencies need to be represented accurately, so we can gradually increase the resolution during sampling.

@ryanlpeterman finding out C++ had a garbage collection API at one point feels like uncovering lost programming lore

Top 3 takeaways I had from my conversation with Bjarne Stroustrup (Creator of C++): 1) How Bell Labs did research - When I asked Bjarne about how project selection went, he talked about two ways of doing research. In one way, you have a well-designed project that is carefully chosen by management. Then the project is staffed with many researchers. This was not the Bell Labs way. The other way was to hire the best people on the planet and don’t tell them what to do. Each year, the researchers would be asked to explain what they did in 9pt font or larger on a single page. If you can’t explain what you’re doing concisely, it probably isn’t that interesting. If the work was interesting enough, then you could continue to work on it. Even though this was unusual, the results speak for themselves as much of the technology we take for granted today was invented at Bell Labs. 2) Negative overhead abstraction - Coming into the conversation, I assumed that more abstraction meant you’d lose performance but Bjarne corrected my naive assumption. A simple example is to look at C vs C++. Because C++ encodes more information in the language itself, the compiler has more it can use to optimize the final result. Therefore, the abstractions in C++ can be used to get better performance actually. 3) There was a garbage collection API in C++ - I had always assumed that where there was C++, there was manual memory management. I was wrong. In 1995, Bjarne introduced a standard interface for garbage collection due to user requests. However, C++ developers tended to prefer manual resource management so the garbage collection API never got much use. Later, this garbage collection interface was removed from the standard. This is probably why you don’t hear too much about this. Full conversation below: