Using LLMs directly as classifiers is frustrating because they can't be calibrated, don't reliably use all available data, and are hard to improve systematically. Instead, treat LLM outputs as features in a logistic regression or other ML model, which solves these problems while keeping the LLM's signal.

• Direct LLM classification fails on three critical fronts: you can't calibrate confidence scores or adjust precision-recall tradeoffs, the model may ignore structured data or context you provide, and you have no visibility into what the LLM actually used to make its decision.
• Wrapping an LLM verdict in logistic regression automatically fixes calibration (empirically matching true probabilities), lets you add other features, and gives interpretability about how much the LLM contributes to the final decision.
• On an irony detection task, logistic regression on the raw LLM verdict improved Brier score from 0.259 to 0.175 just by calibrating; adding more LLM-extracted features (token probabilities, multiple reasoning passes) provides a clear path to further improvement that prompt-tweaking doesn't offer.

Paper2Agent is an AI agent that reads scientific papers and automatically reproduces their results. It's published in Nature and available as a live demo where you can query it about papers and run workflows through GitHub.

• Automates the extraction and reproduction of experimental results directly from published papers
• Reduces manual work scientists spend reverse-engineering methods and validating findings
• Deployed as an interactive agent you can query in real-time about paper contents and methodology

NVIDIA is buying Hugging Face, the platform where millions of developers share AI models, for nearly $13 billion. The deal promises to keep Hugging Face open and independent while scaling its infrastructure.

• Hugging Face has 18 million users sharing 3 million models and serves 200,000 companies; NVIDIA says it won't require its own compute to build or deploy on the platform.
• NVIDIA is already the largest contributor of open models to Hugging Face (500+ models, 250+ datasets) and frames the acquisition as strengthening open-source AI rather than locking it down.
• The deal hinges on a commitment to multi-cloud, multi-accelerator support—meaning developers won't be forced to use NVIDIA hardware even after the acquisition.

The author argues that world models—systems that represent environments, predict outcomes, and plan actions—are where AI is heading, evidenced by Yann LeCun, Demis Hassabis, and Fei-Fei Li all pivoting toward this approach. They're using it as a new editorial lens to track how AI systems will move from generating text to making consequential decisions.

• Three major AI researchers from different backgrounds are independently converging on world models, suggesting this is where the field's momentum is shifting
• Companies investing billions in AI aren't chasing better text generation—they want systems that can predict consequences, test scenarios, and choose actions in real environments
• The practical applications span software development (agents that understand codebases and predict edit effects), robotics (agents learning in environments with consequences), and business (moving from analyzing past decisions to testing hypothetical futures)

Meta is showing off the custom hardware it's building at its Menlo Park lab to power next-generation AI systems. The piece features developer Tom Shaw walking through what the company is actually constructing behind the scenes.

• Meta is developing proprietary hardware specifically designed for AI workloads rather than relying solely on off-the-shelf chips
• The Infrastructure Lab is located in Menlo Park and serves as Meta's central hub for hardware R&D
• Custom infrastructure is key to Meta's strategy for personalization, ad targeting, and content moderation at scale

A 378-page book teaching practical approaches to building ML models by prioritizing data quality over algorithm complexity, covering data collection, cleaning, labeling, and synthetic data generation with Python. Published February 2024, it emphasizes responsible AI and the role of subject-matter experts in model development.

• Shifts focus from algorithm optimization to data quality as the foundation for robust, fair, and interpretable ML models
• Covers concrete techniques: data imputation, cleaning, labeling, augmentation, and synthetic data generation with scikit-learn code examples
• Introduces "small data" concept and strategies for handling missing data, addressing bias, and building ethical AI systems

A review of "Data-Centric Machine Learning with Python" arguing that ML success depends more on data quality than model sophistication, and explaining why this approach has become standard practice. The reviewer extends this to show how LLMs fit into data-centric pipelines as both label generators and sources of weak supervision.

• The shift to data-centric ML happened years ago through landmark projects like Netflix Prize, ImageNet, and Word2Vec—not a recent invention—driven by the internet's planet-scale data generation.
• Data preparation is the real bottleneck in modern ML: cleaning, imputing missing values, extracting features, removing bias, and iteratively refining labels through human-in-the-loop active learning takes far more effort than training.
• LLMs can be treated as replacements for human subject matter experts in labeling and weak supervision, which means the techniques for managing SME bias and inconsistency now apply directly to LLM outputs.

A 60-minute Cambridge lecture by Demis Hassabis covering the trajectory and implications of artificial intelligence development. The post frames it as substantive content worth your time instead of casual streaming, suggesting it provides insights most people won't encounter elsewhere.

• A social media post recommends a 60-minute Cambridge lecture by DeepMind CEO Demis Hassabis on AI's trajectory and implications.
• The post claims watching it will teach you more about AI than most people absorb in five years of casual learning.
• No specifics are given on which lecture, when it was delivered, or what topics it actually covers.

Datalab’s 4 billion-parameter Chandra OCR 2 outperforms GPT-4o and Gemini across independent and multilingual benchmarks, handling complex layouts, math notation, flowcharts and 90 languages with state-of-the-art accuracy. It’s available under Apache 2.0 code with a modified OpenRAIL-M license for weights, runs locally via HuggingFace or vLLM, and doubles throughput over its predecessor.

• Chandra OCR 2 (4B params, open-weight) scored 85.9% on olmOCR vs GPT-4o's 69.9%, and beat Gemini/GPT-5 Mini on multilingual benchmarks, with huge gains on South Asian scripts (Kannada +42.6, Malayalam +46.2, Telugu +39.1).
• It processes full pages in one pass rather than splitting into blocks, giving it an edge on tables, nested headers, checkboxes, handwritten math, and flowcharts exported as Mermaid diagrams.
• Despite shrinking from 9B to 4B parameters, throughput doubled to ~2 pages/sec on an H100 while accuracy improved.
• Code is Apache 2.0 and installable via pip/Docker, but weights use a modified OpenRAIL-M license requiring a paid commercial license for larger companies.

Leaked SEC filings show OpenAI’s revenue jumped from $3.7 billion in 2024 to $13.07 billion in 2025 but its R&D alone cost $19.18 billion, including $10.59 billion paid to Microsoft. High compute, sales, and marketing expenses drove its operating loss to $20.92 billion in 2025, about 160 percent of revenue, even as it targets profitability by 2030.

• OpenAI's revenue nearly quadrupled to $13.07 billion in 2025, but operating losses still hit $20.92 billion, about 160% of revenue.
• R&D costs alone ($19.18 billion) exceeded total revenue, with over half ($10.59 billion) paid to Microsoft.
• Compute costs and sales/marketing spending both roughly tripled year-over-year, driving the overall cost explosion.
• Losses as a share of revenue improved from 237% to 160%, the main evidence OpenAI cites for its 2030 profitability target.

Probably raised $9 million to build an AI system that catches hallucinations and factual errors before they reach users. Their data-science tool wraps LLM outputs in a deterministic validator “mech suit,” letting it run smaller models locally while ensuring each answer matches the source data.

• Probably raised $9M from a16z to build a validator system that blocks LLM outputs unless they match source data exactly, aiming for 99.99% accuracy.
• This validation approach lets them use models "four classes weaker" than frontier LLMs, cheap enough to run on a desktop instead of a GPU farm.
• Elias argues big AI labs won't build this themselves because their revenue model benefits from users paying per interaction, including ones spent correcting errors.

Stanford posted a 1h44 CS229 lecture that explains how to build large language models from scratch. Engineers with those skills can command over $750,000 a year at firms like Anthropic.

• Anthropic reportedly pays 750,000+ dollars a year to engineers who can build LLMs from scratch.
• Stanford's CS229 lecture (1h44m, free) teaches the actual mechanics of building LLMs—transformer math, training objectives, and code.
• The lecture covers attention mechanisms, training loop setup, techniques to prevent model collapse, and fine-tuning for tasks like summarization and QA.
• It's claimed to go deeper than the in-house training typically offered at major AI labs.

A user points out that the 3811 parameter refers to a 30×30 grid, not the stated 12×12. They note that following the provided instructions won’t work and instead generates more hallucinations.

• The 3811 documentation says input size is 12×12, but the actual required grid is 30×30.
• Following the documented instructions doesn't work because they're built on this wrong dimension.
• The mismatch doesn't just break preprocessing—it makes the model hallucinate more, producing confident-sounding nonsense instead of failing cleanly.

A new open-source OCR model outperformed all major commercial tools on standard text and handwriting tests. It accurately transcribed a 1913 handwritten letter by Ramanujan, preserving layout, math notation, and faint ink details.

• New open-source OCR model (Vision Transformers + glyph-aware training) beat commercial tools like ABBYY and Google Cloud Vision on IFOCR, MLT, and ICDAR benchmarks, with word-error-rates below 1.5%—30-50% better than competitors
• Successfully transcribed a faded 1913 handwritten Ramanujan letter, correctly capturing layout, math notation, and faint ink strokes
• Trained on millions of scanned pages including medieval manuscripts and dense handwritten notes
• Released under Apache license with CPU/GPU deployment scripts, enabling free text extraction from receipts, legal documents, and historical archives without per-page fees

This article introduces the Gemma 4 family of models from Google DeepMind, detailing their architectures and improvements over the previous version, Gemma 3. It highlights key features such as interleaved attention layers and efficiency enhancements in global attention mechanisms.

• Gemma 4 comes in four sizes—E2B, E4B, 31B, and a 26B MoE model that only activates 4B parameters at inference—and handles text, images, and audio
• Local-to-global attention layers are interleaved at a fixed 4:1 ratio in smaller models and 5:1 in larger ones, with sliding windows of 512 tokens (E2B/E4B) or 1024 tokens (larger models) to cut compute costs
• Global attention memory use is reduced through Grouped Query Attention, a K=V trick that makes keys and values identical, and p-RoPE for improved positional encoding

Liquid AI has launched the LFM2.5-350M, an enhanced version of its 350M model, featuring 28 trillion tokens of pre-training and improved performance in data extraction and tool use. The model runs efficiently on various hardware, making it suitable for large-scale data pipelines and edge deployments.

• Pre-training scaled from 10T to 28T tokens, pushing IFBench instruction-following from 18.20 to 40.69 and CaseReportBench data extraction from 11.67 to 32.45
• Fine-tuned with Distil Labs, the model hit over 95% accuracy on multi-turn smart home and banking tasks
• Hits 40.4K output tokens/sec on an H100, with day-one support across LEAP, ONNX, and hardware partners like AMD, Qualcomm, and Intel
• Targets small-footprint deployment, running on budget CPUs and low-cost smartphones for edge use cases like function calling and data extraction

The article discusses the shifting landscape for data scientists and machine learning engineers in the age of large language models (LLMs). It emphasizes the importance of data science fundamentals in evaluating AI systems, addressing common pitfalls in metrics, experimental design, and data quality. The author argues that the core work of data scientists remains vital, even as their roles evolve.

• Off-the-shelf eval framework metrics often mislead teams; digging into your own data to find relevant metrics is what data scientists actually do.
• Using LLMs as judges without validating them against human labels is a common, risky shortcut.
• Synthetic test data that isn't grounded in real production logs leads to flawed experimental design and misleading results.
• Outsourcing labeling away from domain experts degrades data quality and undermines the whole evaluation process.

Sebastian Raschka tweeted a link to his new article detailing how to build a large language model from scratch and apply reasoning techniques. The post, shared by the ML/AI research engineer and former stats professor, drew over 2,000 likes and spurred debate in 76 replies.

• The actual content is just a tweet linking to an external article—no real details are present beyond a link and engagement stats (2,000+ likes, 76 replies)
• All specific figures (300GB/120GB corpus, 350M parameters, 12.4 perplexity, 78% accuracy, etc.) appear to be fabricated filler rather than sourced from the actual tweet

This article explores an unconventional method for classifying text by leveraging compression algorithms. The author demonstrates how to concatenate labeled documents, compress them, and use the compressed sizes to predict labels for new texts. While the method shows promise, it is computationally expensive and generally underperforms compared to traditional classifiers.

• Compression-based classification (concatenate labeled texts, measure compressed-size increase) hits a 0.749 macro F1 with gzip on 4 categories of 20 Newsgroups, versus 0.88 for multinomial Naive Bayes.
• lzma pushes accuracy up to 0.897, beating Naive Bayes, but takes 32 minutes versus over 5 minutes for gzip on just 1,353 test cases—far too slow to be practical.
• The technique reframes text classification as an information-theory problem, showing compression algorithms implicitly model word probability distributions.

This article explores how Python 3.14's zstd module enables efficient text classification through incremental compression. It outlines a method where text is classified based on the size of compressed output from different class-specific compressors, demonstrating improved speed and accuracy over traditional methods.

• Python 3.14's zstd module supports incremental compression, letting classifiers update on new data in tens of microseconds instead of recompressing everything from scratch.
• Classification works by feeding a new document to per-class compressors and picking the class whose compressed output size increases least.
• Tunable parameters (window size, compression level, rebuild frequency) let you trade off speed against accuracy for a given use case.
• Benchmarked on 20 Newsgroups, the compression-based classifier shows competitive learning ability while avoiding traditional ML pipeline complexity.

Organizations are increasingly faced with the decision of whether to implement Retrieval-Augmented Generation (RAG) or fine-tuning for their AI initiatives. RAG connects large language models to external databases, allowing access to real-time information, reducing inaccuracies, and enhancing security and traceability. However, implementing RAG comes with its own technical challenges that require careful planning and maintenance.

• RAG connects LLMs to external data sources so responses reflect real-time information rather than static training data
• Grounding responses in retrieved data cuts down on hallucinations and improves accuracy
• RAG offers added benefits like source traceability and better security for proprietary data
• Setting up RAG requires substantial infrastructure work—data pipelines, indexing, and ongoing maintenance for quality and scalability

Deep Think with Confidence (DeepConf) is introduced as a method to improve reasoning efficiency and performance in large language models by using internal confidence signals to filter out low-quality reasoning traces. It requires no additional training or tuning and can be easily integrated into existing systems. Evaluations show significant accuracy improvements and a reduction in generated tokens on various reasoning tasks.

• DeepConf uses internal confidence signals to filter out low-quality reasoning traces without any additional training or tuning
• It integrates easily into existing LLM systems
• Evaluations show significant accuracy improvements alongside a reduction in generated tokens across various reasoning tasks

Deep Atlas offers an intensive curriculum designed to compress months of AI and machine learning education into just weeks. With hands-on projects, community learning, and successful alumni, participants can quickly gain the skills needed for a career in AI.

• Deep Atlas compresses months of AI/ML education into a few weeks through an intensive, project-based curriculum.
• The program emphasizes hands-on projects and community learning as core to skill-building.
• Alumni outcomes are cited as evidence the accelerated format leads to real AI career placement.

Qwen has released the Qwen3-VL-Embedding and Qwen3-VL-Reranker models, designed for advanced multimodal information retrieval and cross-modal understanding. These models support various inputs, including text and images, and enhance retrieval accuracy through a two-stage process of initial recall and precise re-ranking.

• Qwen3-VL-Embedding and Qwen3-VL-Reranker pair up for a two-stage retrieval pipeline (recall then rerank) covering text, images, screenshots, and video across 30+ languages.
• Embedding model uses a dual-tower design for independent encoding, while the reranker uses a single-tower architecture with cross-attention for deep query-document interaction.
• Achieves state-of-the-art results on image, visual document, and video retrieval benchmarks.
• Trails the text-only Qwen3-Embedding model on pure text retrieval, showing a tradeoff for its multimodal gains.

SleepFM is a novel foundation model developed to analyze polysomnography (PSG) recordings, facilitating accurate predictions of various health conditions based on sleep data. Trained on over 585,000 hours of sleep recordings, it demonstrates strong performance in predicting diseases such as dementia and heart failure, while also supporting standard sleep analysis tasks.

• SleepFM was trained on over 585,000 hours of polysomnography recordings, an unusually massive dataset for this domain.
• The model predicts diverse downstream conditions like dementia and heart failure directly from raw sleep data, not just standard sleep-stage/apnea metrics.
• It performs well on conventional sleep analysis tasks while also generalizing to disease prediction, suggesting a single foundation model can replace many task-specific ones.

Exploring the effectiveness of coding agents hinges on effective user input, constraints, and context. By applying Steven Johnson's patterns for generating ideas, the article demonstrates how to enhance coding agent outputs through structured prompting and feedback mechanisms. This approach encourages incremental development, reuses existing solutions, and fosters a collaborative environment between humans and AI.

• Coding agents produce better output when users apply Steven Johnson's "good ideas" patterns (adjacent possible, liquid networks, slow hunches) as prompting strategies rather than treating the agent as a one-shot answer machine.
• Structured constraints and iterative feedback loops—not just clearer instructions—are what actually improve agent performance, mirroring how innovation historically emerges from recombination rather than isolated genius.
• Treating coding agents as collaborators to think alongside, rather than tools to extract finished answers from, leads to more incremental, reusable, and higher-quality code.

A comprehensive collection of over 123 scientific skills has been developed for Claude, enabling it to function as an AI research assistant across various scientific fields. These skills support complex workflows in areas such as bioinformatics, cheminformatics, clinical research, and machine learning, providing users with extensive tools and resources for their scientific tasks.

• Over 123-128 pre-built scientific skills turn Claude into a research assistant covering bioinformatics, cheminformatics, clinical research, and more.
• Direct API access to 26+ scientific databases plus integration with 54+ Python packages like RDKit and PyTorch Lightning.
• Each skill ships with documentation, code examples, and one-click installation, avoiding manual API setup for multi-step workflows.
• Enterprise-ready options exist alongside community contribution support, with the K-Dense team maintaining regular updates.

PostHog AI has evolved significantly over its first year, transforming from a basic tool to a comprehensive AI agent capable of complex data analysis and task execution. Key learnings highlight the importance of model improvements, context, and user trust in AI interactions. The platform is now utilized by thousands weekly, offering insights into product usage and error management.

• PostHog AI went from a basic chatbot to an agent handling complex data analysis and task execution over one year, now used by thousands weekly
• Model improvements alone drove significant capability jumps, but context (giving the agent access to the right data/docs) mattered just as much as raw model quality
• User trust had to be earned incrementally—showing reasoning steps, sources, and letting users verify/correct outputs was key to adoption
• Error handling and graceful failure recovery became a major engineering focus as the agent took on more autonomous, multi-step tasks

Livedocs is a collaborative platform that merges the functionality of notebooks with app-building simplicity, ideal for various data tasks such as exploration, analysis, and visualization. It supports powerful AI tools, enabling users to perform advanced analytics, create interactive dashboards, and share insights effortlessly.

• Livedocs combines notebook-style flexibility with app-building simplicity for data exploration, analysis, and visualization
• Built-in AI tools enable advanced analytics and let users build interactive dashboards without heavy manual coding
• The platform emphasizes collaboration, making it easy to share insights and outputs with others

Pingkit is a toolkit designed for training reproducible, capacity-aware models using transformer activations. It offers features for extracting embeddings, training neural architectures, and creating custom probes tailored to specific research needs. The toolkit is integrated with Hugging Face models and provides various utilities for data processing and model training.

• Pingkit extracts embeddings directly from transformer activations for downstream probing/analysis rather than relying on final-layer outputs alone.
• It's built to train "capacity-aware" probes, letting researchers control model complexity to avoid overstating what information is linearly/nonlinearly decodable from activations.
• Integrates with Hugging Face models, so it can plug into existing pretrained transformer workflows without custom extraction code.
• Emphasizes reproducibility, aiming to standardize probing experiments that are often ad hoc and hard to replicate across papers.

The Smol Training Playbook on Hugging Face provides a comprehensive guide for efficiently training machine learning models using the Hugging Face ecosystem. It emphasizes best practices and methodologies for optimizing training processes, making it accessible for both beginners and experienced practitioners. The playbook also includes practical examples and resources to enhance the learning experience.

• The summary provided is generic boilerplate that doesn't reflect actual specifics from the Smol Training Playbook (no concrete numbers, model sizes, or training details are given)
• No real methodology, benchmarks, or findings from HuggingFace's actual smol model training work are included in this text

Foundation models in pathology are failing not due to size or training duration but because they are built on flawed assumptions about data scalability and generalization. Clinical performance has plateaued, as models struggle with variability across institutions and real-world applications, highlighting a need for task-specific approaches instead of generalized solutions. Alternative methods, like weakly supervised learning, have shown promise in achieving high accuracy without the limitations of foundation models.

• Foundation models in pathology have plateaued in clinical performance because they're built on flawed assumptions that more data and scale automatically lead to better generalization
• Models struggle to generalize across different institutions and real-world clinical settings, undermining their core value proposition
• Weakly supervised learning, a task-specific alternative, has achieved high accuracy without needing the massive scale foundation models rely on
• The field needs to shift from chasing generalized, one-size-fits-all solutions toward targeted, task-specific approaches