Google Research Blog

Google — Invalid Date

Large language models (LLMs) are increasingly being deployed not just as coding assistants but as autonomous agents capable of conducting end-to-end scientific research workflows. Recent systems (e.g., Sakana’s AI-Scientist, AutoResearchClaw, DeepScientist, AI-Researcher) can review literature, formulate hypotheses, execute experiments and write complete manuscripts that are comparable to human-authored papers. However, as the surface-level quality of these AI-generated manuscripts improves, a critical structural problem has emerged: verifiability. Because current autonomous research pipelines generate text iteratively, errors introduced at any stage are amplified. Some existing systems can generate non-existent citations, exhibit misalignments between the described methods and the actual code, and report experimental scores that are not fully reproducible from the provided code.

In our paper, we tackle this problem by introducing Chain-of-Evidence (CoE), a new verifiability framework for AI-driven research. We instantiate CoE with the Science One Framework, an autonomous research prototype that natively builds and maintains evidence chains, and the CoE Audit, a set of automated evaluation metrics that measures the integrity of AI-generated papers against their underlying code and evidence. Our results show that baseline systems hallucinate up to 21% of their references and frequently misalign their code and text, whereas the Science One Framework achieves zero phantom references and fully verifiable scores while achieving state-of-the-art performance on frontier benchmarks like MLE-Bench and Parameter-Golf.

Chain-of-Evidence: A framework for verifiable research

The CoE is a conceptual framework that defines what makes a research artifact trustworthy, much as ACID defines what makes a database transaction reliable. Rather than prescribing how to build a research agent, the framework specifies the properties its outputs must have. It follows a single principle with two halves: every claim in a research artifact must carry a recorded evidence chain (completeness), and each chain must genuinely support the claim it is attached to (correctness). A claim may be a reference, a reported number, a method description, or a conclusion, that must link back to corresponding evidence, such as a peer-reviewed paper, an experimental log line, the code that actually ran, or the results table.

A hallucinated reference points to a paper that does not exist. An unreproducible score does not reappear when the code is re-run. A misdescribed method claims one algorithm in the paper while the code implements another. Each is a claim whose chain back to its evidence is broken; the CoE Audit makes these breaks measurable.

The Science One Framework

To demonstrate that verifiable AI research is possible without sacrificing problem-solving performance, we designed the Science One Framework. Unlike previous agents that generate a paper and try to link facts retroactively, the Science One Framework instantiates the CoE framework by construction through three main modules:

Problem investigator (literature grounding): To prevent hallucinated references, the Science One Framework builds a citation graph via the Semantic Scholar API. It reads up to 100 full-text PDFs per topic to produce a structured research brief. Every reference in the final paper originates from this grounded API call entirely eliminating reliance on model memory.
Discovery engine (parallel explore-exploit): The Science One Framework systematically explores and exploits ideas across multiple parallel branches. In each isolated cycle, a Solver agent implements a solution and a task-specific evaluator scores it. High-performing branches are iteratively refined, and all raw evaluator outputs are compiled into a strict, read-only record.
Paper writer and claim verifier: Before rendering the manuscript, the Science One Framework builds a structured representation of every factual claim with an inline evidence tag binding it to a specific workspace artifact. A dedicated Claim Verifier checks every claim against its declared source. Claims that outrun their evidence are reconciled with the source — restated conservatively rather than removed, keeping the paper aligned with what the work supports.

The Science One Framework pipeline. Problem Investigator grounds literature via retrieved PDFs. Discovery module explores and evaluates solutions. Paper writing & verification module writes and verifies the paper with a Claim Verifier ensuring all claims match their evidence source.

CoE Audit: Measuring verifiability

To rigorously evaluate the Science One Framework prototype against state-of-the-art baselines (e.g., Sakana AI's AI Scientist v2, AutoResearchClaw, DeepScientist, AI-Researcher), we developed the CoE Audit. This post-hoc evaluation protocol acts as an automated forensic reviewer, running four strict integrity checks on the generated artifacts (paper, solution, code and references):

Score verification: Extracts the reported score from the paper and compares it against a completely independent re-run of the submitted code.
Specification violation: Inspects the solution code to ensure it actually solves the task rather than exploiting the evaluator metric or reading ground-truth answer files.
Reference verification: Cross-checks every bibliography entry against academic APIs to catch non-existent phantom references.
Method-code alignment: Uses LLM judges to compare the paper's method section side-by-side with the code to ensure the text faithfully describes the implemented algorithm.

Overview of the CoE Audit framework and its four core integrity checks.

Results

We applied the CoE Audit to 75 papers generated across five systems-optimization tasks (Prism, Cloudcast, EPLB, LLM-SQL, and transaction scheduling) from the Automated Design of Research Systems (ADRS) benchmark.

The Science One Framework significantly outperformed existing baselines in verifiability. The CoE Audit applies the same independent protocol to every system, re-checking each reference against live scholarly databases, and under it, Science One Framework led on all four integrity checks. None of its references were phantom: every one pointed to a real, retrievable paper, compared to hallucination rates as high as 21% in baselines, because the Problem Investigator retrieves every reference rather than generating it from memory. It also achieved perfect score verification and the highest method-code alignment. In contrast, baseline systems frequently described sophisticated algorithms (like "hybrid neuro-symbolic solvers") when their submitted code was a simple, deterministic heuristic.

CoE Audit results across five systems.

Crucially, implementing strict verifiability did not compromise the agent's scientific capabilities. The Science One Framework matched or exceeded human expert performance on all five ADRS tasks, achieving the best overall score among all systems on two of them (Cloudcast and EPLB).

Comparison of solver performance across five MLE-Bench tasks and Parameter Golf.

To test its generalization, we deployed the Science One Framework on six highly complex external tasks:

MLE-Bench: Across five difficult Kaggle competitions spanning medical imaging, fine-grained recognition and 3D perception, Science One Framework achieved two Gold Medals (including a winning score on 3D Object Detection where baselines failed entirely) and two Silver Medals.
Parameter-Golf: We tested Science One Framework in a live LLM-training competition with strict hardware and file-size constraints. While baseline systems failed to produce valid submissions, Science One Framework successfully adhered to all constraints and achieved a state-of-the-art score (as of April 27, 2026). Note that Science One Framework discovers genuine and novel algorithmic techniques rather than just tweaking superficial hyperparameters.

Looking forward

As autonomous research systems scale to solve increasingly difficult scientific problems, solver quality alone will no longer be enough to differentiate them. What will separate their outputs is whether the resulting research can be trusted. Our findings demonstrate that verifiability must be treated as a first-class architectural constraint. By building evidence chains at the time a claim is produced rather than attempting to reconstruct grounding after the fact, The Science One Framework demonstrates that AI agents can produce rigorous, trustworthy and highly competitive scientific research. We hope the Chain-of-Evidence framework and its audit will serve as valuable tools for the community as we continue to build the next generation of AI scientists.

Acknowledgements

We would like to thank Bhavana Dalvi Mishra, Jiefeng Chen, Chun-Liang Li, Palash Goyal, Mihir Parmar, Yiwen Song, Yale Song, Raj Sinha, Parthasarathy Ranganathan, Burak Gokturk and Jinsung Yoon for their valuable contributions to this work.

Disclaimer

The Science One Framework is an experimental research prototype, not production-ready tools.

Google — Invalid Date

A large proportion of clinical diagnoses can be derived from language-based interviews alone. These diagnostic interviews are typically conducted by clinicians through doctor-patient interactions during in-person or remote visits. While these interactions are the gold standard for symptom assessment, they can often suffer from financial, geographic, and systemic barriers that limit their accessibility. Current language models (LMs) have demonstrated strong differential diagnosis assessment capabilities when evaluated on curated medical case-studies, highlighting their potential to support the diagnostic process. However, existing evaluations have largely relied on curated, highly detailed and sometimes synthetic patient vignettes, which may not reflect real world experience and clinical presentation variability. These evaluations do not capture how everyday patients report their health symptoms, for example with varying levels of medical literacy, incomplete information, and other complexities that arise through natural conversation. This represents a key gap, leading to uncertainty of how LMs might perform in real-world contexts.

To address this gap, we conduct an in-situ comparative research study of a set of experimental conversational prototype AI agents designed to explore how conversational AI might conduct end-to-end symptom interviews and differential diagnostic assessment for research benchmarking purposes. In our recent research paper, “SymptomAI: Towards a Conversational AI Agent for Everyday Symptom Assessment”, we share results from a randomized national scale study (n=13,917) in which consented research participants interact with one of five possible Gemini Flash 2.0 SymptomAI agents. All diagnoses, labels, and disease associations generated during the study were for research analysis only and did not constitute confirmed clinical diagnoses or official medical assessments. Two weeks after their interaction with the AI agents, we asked research participants to report any diagnoses they received from a visit with a healthcare provider. Using this data, we conducted a clinical expert annotation study comparing SymptomAI’s diagnostic performance relative to real clinicians' medical assessments.

After assessing the accuracy of SymptomAI’s differential diagnoses (DDx), we further compare SymptomAI’s diagnoses against biosignals from participants’ Fitbit wearable devices in the time leading up to their conversation with SymptomAI. We show that SymptomAI conversations that led to diagnosis with an infectious disease etiology coincide with physiological trends that may indicate an immune response, suggesting further evidence of SymptomAI’s performance.

For this research, we administered a set of conversational AI agents for end-to-end patient interviewing and differential diagnostic assessment. A participant could converse with an agent about their symptoms, receive a candidate differential list and enter a subsequent diagnosis.

How it works

We enrolled 13,917 consenting research study participants who each describe their symptoms to one of five randomized SymptomAI agents, each with varying degrees of flexibility in how they conducted the symptom interview. During these conversations, participants described their symptoms and SymptomAI asked follow-up questions, with conversations culminating in a final differential diagnosis (DDx, a list of plausible diagnoses) and recommendations for next steps. Participants could then go on to see a healthcare provider and were asked to share the outcome of that visit via a survey two-weeks later. To evaluate and baseline SymptomAI’s assessment, we conducted a clinical-expert annotation study in which a panel of three board-certified clinicians reviewed the conversation transcripts and provided their own assessment (i.e., differential diagnosis). Then each clinician, in a blinded fashion, ranked the DDx provided by SymptomAI and those provided by the remaining clinicians.

Key results

Clinical experts preference for SymptomAI DDx

We found that the clinicians preferred the DDx generated by SymptomAI over those provided by the other clinicians in over 50% of the cases. This indicates that SymptomAI DDx aligned with our clinicians’ medical assessments just as often or more often than that of other clinicians.

The SymptomAI generated DDx were more likely to be ranked as the best DDx in overall quality by our clinical raters.

Clinical experts found SymptomAI DDx to be more accurate

Similarly, we compare the accuracy of the DDx generated by SymptomAI and provided by real clinicians via top-5 Accuracy (i.e., whether the true diagnosis provided by our participants' personal healthcare provider appears as one of the five possible diagnoses in the DDx). We had our clinicians each identify whether the provided diagnosis was in each DDx, including both the DDx generated by SymptomAI and those provided by clinicians. We found that the clinicians ranked the DDx generated by SymptomAI to be accurate more often than the DDx provided by other clinicians.

The SymptomAI generated DDx were more likely to contain the self-reported diagnosis provided by a healthcare provider.

Eliciting more information improves performance

As part of this research, we assessed different approaches for conducting history taking interviews. Participants were randomly assigned to five study arms, each employing different prompting strategies. Two (Dynamic Live and Dynamic Final) were given total agency to ask unrestricted follow up questions, two more (Fixed Canonical and Flexible Canonical) each asked questions from a set of standard history taking questions taught in medical school, and finally a Base unprompted LM, representing the fully user-driven experience that is the current status quo when querying LM chatbots. We found that all agent-driven prompting strategies (i.e., where SymptomAI actively asked follow up questions) significantly outperformed the Base condition, demonstrating the value of eliciting information from participants for improving differential diagnostic accuracy.

Accuracy of Symptom AI and clinicians by SymptomAI experiment arm.

Total user word count by SymptomAI experiment arm.

SymptomAI performance on low-confidence examples

We found that SymptomAI’s performance above clinical baselines was greatest for cases where the clinician’s felt least confident in their own DDx.

The top-5 accuracy assigned by clinicians to SymptomAI and baseline clinician-generated DDx stratified by the baseline clinician’s confidence in their own DDx.

Diagnosis from SymptomAI correlates with biosignals

Given SymptomAI's accuracy against clinical baselines, we can also explore its potential at scale. Currently, the cost of clinical labels prohibits real-world analyses of population-scale datasets. Accurate symptom checking systems like SymptomAI have the potential to enable automated reference labeling of clinical quality diagnosis, which can open up large-scale analyses of physiological data — a task that is currently impossible at scale.

One such example is correlating wearable biosignals with different categories of illness. The most notable changes in wearable biosignals are observed for acute respiratory infections. To study this at population scale, we collected daily biometric data from our consenting participants for up to 30 days prior to their interaction with SymptomAI. We find clear biosignal shifts indicating symptom onset in the days approaching the user's symptom reporting. Importantly, the separation between cohorts was derived through categorizing SymptomAI's top-1 candidate diagnosis and grouping diagnoses that were classified as respiratory infections. This cohort excludes non-infectious respiratory illnesses like allergic rhinitis or chronic obstructive pulmonary disease. The correlation of wearable biosignals shift peaks aligning with the date of symptom reporting for these participants serves as observational physiological evidence that align with their reported symptoms.

Wearable biosignals in the days leading up to a SymptomAI conversation relative to a historic average from a baseline period across day -30 to -15 for the infected (red) and baseline (gray) cohorts. The infected cohort includes participants which SymptomAI diagnosed with a respiratory infection while the baseline includes all other participants in our dataset. Day 0 denotes the date of the SymptomAI conversation.

Utility alongside biosignals

AI-based assessment of symptom presentations opens the door to new research. By using SymptomAI to analyze a large volume of symptom reports and pairing those with real-time Fitbit data, we can explore digital biosignal phenotypes across a wide range of diseases. Our analysis revealed distinct shifts in physiological metrics — including cardiovascular function, respiration, skin temperature, and sleep quality — in the days leading up to a user's SymptomAI conversation. These objective changes align closely with the timing of the symptom conversation, offering a potential way to validate patient-reported symptoms or provide passive data to help inform a differential diagnosis alongside their symptom conversation. Additionally, this real-time accessibility highlights a core benefit of AI symptom checkers. Unlike traditional clinical appointments that can suffer from scheduling delays, participants could take part on the SymptomAI research study contemporaneously while symptoms are fresh. This potentially could improve the accuracy of patient-reported onset timelines — a crucial detail for population-scale health analysis.

Limitations

SymptomAI is an exploratory research effort that could represent a significant research advancement in AI-based symptom assessment and demonstrates the potential it could provide for the general public seeking understanding of their symptoms. While a population deployment evaluation reveals the accuracy of symptom assessment through remote patient interviews, there are nuanced limitations when comparing against clinician’s assessments.

Firstly, differential diagnosis itself is an ambiguous task and even reported diagnoses may change and develop longitudinally. A symptom assessment is a snapshot in time and captures the symptoms as they present in that moment. Due to the scale of our deployment, we were unable to control for frequency and timing of symptom reporting. As a result, some participants may have reported their symptoms well before more representative indicators developed, while others may have reported obvious indicators from an informed context after years of experience with chronic illness. Future work may focus on specific illnesses at specific points during symptom development such as early-onset metabolic syndrome or symptoms discussed at the start of respiratory infections. All diagnoses, labels, and disease associations generated during the study are AI-derived for research analysis only and do not constitute confirmed clinical diagnoses or official medical assessments.

Secondly, in our evaluation the clinicians reviewed static chat transcripts and were not given agency to ask their own follow-up questions. Clinicians may have intuitively sourced different information had they directed the symptom interview. Moreover, while recent research has shown that conversational AI systems can source clinical data with a clinician-level of detail and accuracy, such systems may miss alternative signals like body language, visual assessment, medical records, or in the context of primary care, existing rapport with the patient.

In conclusion, we introduce SymptomAI, an investigational conversational AI agent for conducting real-world patient interviews and symptom assessments. We demonstrate SymptomAI’s end-to-end real-world performance through DDx accuracy on a population sample, and show how SymptomAI diagnoses can enable analysis of population-scale signals like wearable biosignals for identifying associations in physiological signals with reported illness.

Acknowledgements

This work is the result of equal contributions from Joe Breda, Jake Sunshine and Daniel McDuff. We would like to thank our co-authors and collaborators from Google Research and Google DeepMind for their contributions to this work.

Google — Invalid Date

Imagine a symphony orchestra performing a complex masterpiece. If the violins drifted out of tune every few measures, the ensemble would constantly have to stop and retune their instruments. Thankfully, this doesn't happen in an orchestra because the instruments reliably stay in tune. However, it is the current reality of operating a quantum computer.

Since quantum computers are fundamentally analog machines that are sensitive to drift, maintaining reliable operation requires perpetually recalibrating their control parameters, i.e., the frequencies, amplitudes, and phases of the analog signals choreographing the qubits. Today, this requires fully terminating the entire quantum computation. This complete decoupling of computation and calibration represents a fundamental bottleneck for the future, as useful quantum algorithms must run continuously for days or even months.

To address this, in “Reinforcement learning control of quantum error correction”, published in Nature, we demonstrated a reinforcement learning (RL) framework in which an autonomous agent learns from quantum error detections to continuously steer thousands of control parameters, stabilizing the quantum system against drift during the computation. In short: we found a way to tune the instruments while the music plays.

Dealing with quantum errors

In a concert hall, a detuned instrument is immediately heard. The quantum realm offers no such luxury. As if the very act of listening ruined the performance, measuring the qubits collapses their quantum superposition states. To preserve the quantum information, we instead employ Quantum Error Correction (QEC), a technique that exploits redundancy to create “logical qubits” out of many physical qubits, and uses specialized parity checks on the physical qubits to digitize the analog noise into binary error detection events.

Unfortunately, these bits only tell us that an error occurred somewhere within a bounded spacetime region of the quantum circuit, not its exact location. It is like hearing a sour note without knowing exactly which musician played it. To pinpoint the likely error locations and calculate the necessary corrections, we rely on QEC decoders, such as the neural network decoder AlphaQubit (trained on real data) and algorithmic decoder Tesseract. If errors are sufficiently rare, these decoders can successfully restore the logical quantum information by analyzing the error detection data. However, decoders leave a crucial question unanswered: why did those errors happen in the first place?

Some errors result from the unavoidable interaction of a quantum system with its surrounding environment, leading to decoherence. This ruthless process destroys macroscopic quantum superpositions, effectively turning quantum computers into classical ones. This fundamental phenomenon is so pervasive that it causes our familiar classical reality to emerge from the underlying quantum laws of Nature. While these environmental errors can never be completely prevented, many others are manifestations of imprecise control calibration and hardware drift – flaws that remain within our power to mitigate.

Beyond traditional physics models

Traditionally, quantum calibration relied on physics models. Its techniques were refined through decades of quantum control research. However, across technological domains, human-crafted models inevitably hit a performance ceiling. Early computer vision stalled when relying on strict geometric rules. Traditional robotics still struggles with kinematic equations that fail to capture the messy reality of contact dynamics and friction. Similarly, the decades-old challenge of predicting protein folding remained largely intractable for traditional physical models until deep learning systems like AlphaFold achieved unprecedented accuracy. Across these fields, new breakthroughs occurred when the approach shifted toward learning directly from data.

Recently, AlphaQubit surpassed the accuracy of the most powerful algorithmic QEC decoders. Now quantum control faces the same ceiling. As quantum processors improve through progress in fabrication and hardware, their errors become dominated by complex phenomena that are challenging for traditional modeling and calibration. Can machine learning bring new advances?

Don’t just correct errors, learn from them!

Google Research has a rich history of pioneering RL to solve problems too complex for traditional programming. Unlike algorithms relying on explicit instructions, RL operates through experience. An autonomous agent tests different behaviors and learns directly from resulting errors to refine its strategy. Applying RL to achieve accurate, continuous quantum calibration felt almost inevitable. Since QEC already generates a steady stream of detection events, we simply granted this data a complementary role. In addition to decoding it and correcting the errors, we employ the detection events as an active learning signal. As computation progresses, the RL agent monitors this data and learns to dynamically steer the control parameters, counteracting drift and preventing new errors.

Quantum computation is physically realized via analog control signals. The quantum error detection events are used by the decoder to infer logical corrections. In our control framework, they are also repurposed as a learning signal, teaching the RL agent to continuously steer thousands of control parameters and stabilize the quantum system during the computation.

Our quantum control experiment

We validated such RL quantum control on our flagship Willow superconducting processor. By deliberately injecting artificial drift of control parameters, we showed that RL steering improved the logical stability of our error-correcting code 3.5-fold, prolonging the time during which the processor acts as a reliable “quantum memory” device.

Typically, tuning the processor to peak performance relied heavily on a “human-in-the-loop” approach, with scientists applying physical intuition to resolve edge cases that are difficult to automate. Yet, even after this exhaustive expert calibration, subsequent RL fine-tuning systematically suppressed the logical error rate by an additional 20%.

The synthesis of all our technologies in this experiment reduced the logical errors in quantum memories to a record low: fewer than one per thousand error correction cycles in the surface code, and one per hundred in the color code.

QEC prolongs the lifetime of logical information in quantum memories based on the surface code (left) and color code (right). RL fine-tuning of our controller improves the quality of QEC by circumventing the limitations of complex physics models and human intuition.

Does it scale?

A critical question from machine learning and quantum researchers is whether this RL approach can scale to large quantum computers of the future. To test this, we conducted numerical simulations with hundreds of qubits and tens of thousands of control parameters.

In our simulation, a miscalibrated system starts at a high physical error rate. The agent steadily reduces it over time by learning improved control parameters, and thanks to QEC the logical error rate (LER) gets suppressed exponentially in system size (i.e. number of physical qubits). Crucially, the speed at which physical error rate is reduced by RL is independent of this size, which allows us to scale this approach to much larger systems.

The simulations confirmed our expectation: the number of required RL training iterations (epochs) is independent of the system size, owing to the local sensitivity of the QEC detection events to errors. However, realizing the full potential of the RL framework requires tighter integration. By speeding up the communication cycle between the agent and the quantum processor, and employing more advanced machine learning methods, we hope to unlock significant additional improvements.

Our work thus enables a new paradigm: a quantum computer that learns from its errors and doesn’t stop computing.

Acknowledgements

We thank our co-authors for their contributions, including building and maintaining the hardware, software, cryogenics and electronics infrastructure. This work was made possible by the Google Quantum AI team at Google Research, in collaboration with teams from Google DeepMind.

Google — Invalid Date

Diffusion models are currently one of the most powerful types of tools for generative tasks that require complex and local structures, such as image generation and molecular discovery. They’ve shown an exciting capability to generalize beyond their training data and, in this sense, exhibit “creativity”. For instance, after being trained with datasets of actual images, they can transform random noise samples into novel, high-quality images.

While this creative capability is impressive, it raises an intriguing question: where does it come from? Understanding the answer to this question is an important step towards demystifying the “black-box” nature of diffusion-based generative AI.

To that end, in "On the Interpolation Effect of Score Smoothing in Diffusion Models", presented at ICLR 2026, we build upon the prior research literature and dive into the mathematics of diffusion models to answer this question. We show that a model’s creativity isn’t a random fluke. Instead, it is a consequence of how neural network training naturally "smooths" the transformation from noise back to the data during the generation process.

Understanding denoising

Training a diffusion model begins with taking a set of real training data samples — like cat photos — and intentionally corrupting them with noise until they become completely unrecognizable. The model is then trained to reverse this corruption step-by-step so that it can reconstruct a realistic-looking image from pure noise, a process called denoising.

If the model learns to perform this denoising process perfectly based only on its training samples, it should produce carbon copies of them during deployment time as well (a behavior known as memorization). In this scenario, the model acts as a retrieval tool rather than as a creative engine capable of generating novel outputs.

In practice, however, diffusion models usually do more than just memorize; they generalize to generate new data samples.

To understand how diffusion models actually denoise data, imagine random noise as a cloud of gas particles scattered across a room, where a “force field” pulls each particle in a specific direction until they form a meaningful shape. In a diffusion model, the moving particles are individual data points undergoing denoising. The “force field” is the score function (SF), which is learned from the training data and dictates where the particles should flow at any given moment.

If the model relies on a score function learned perfectly from the training data, the force field will drive the particles into positions that exactly replicate the training data points (i.e., memorization).

The score function drives the denoising process which turns pure noise into meaningful data (e.g., images).

Diffusion model creativity: The 1-dimension example

We discovered that the creativity of diffusion models actually originates from the approximate nature of how neural networks typically learn: imperfect training due to regularization naturally leads to a slight blurring of the learned score function in a process called “score smoothing” (Scarvelis et al., TMLR 2025). This, in turn, causes the denoising process to generate data that interpolates (in other words, fall in the space between) the training points, thus creating new and plausible data samples.

Imagine a one-dimensional world with only two training data points: +1 and -1. At late stages of the denoising process, the “perfect” score function looks like the curvy gray line in the figure below, which has a steep change of sign halfway between the two points, meaning a rapid switch in the direction of pull near 0. In other words, the whole space is divided almost sharply into two, with particles on the left pulled towards -1 and particles on the right pulled towards +1. In the end, every particle converges to one of the two training data points, and thus, memorization occurs.

The “perfect” score function drives the denoising process to collapse onto the training data, thus leading to memorization (the background color and its opaqueness indicate the direction and strength of the pull: red for rightward, blue for leftward).

In practice, however, diffusion models don’t have access to the “perfect” score function but use an approximate version learned by a neural network. Because of the regularization effect of weight decay during training, neural networks have a hard time learning functions with these sharp cliffs. Instead, they tend to learn smoother versions of the “perfect” score function, softening the steep drop into a gentler slope. To illustrate this, we set up an experiment to train two-layer ReLU neural networks to fit the score function in a 1-D example, with the neural networks’ parameters optimized by the popular AdamW algorithm under varying degrees of weight decay (WD).

Neural networks trained under regularization learn smoother versions of the score function.

The stronger the weight decay is, the smoother the learned score function is in the middle area, meaning that particles in that region flow slower than before and will eventually rest within the “interpolation zone” between the two training data points.

Score smoothing creates an “interpolation zone” between training data points.

In the paper, we quantify this connection by combining the function-space theory of neural network regularization (Savarese et al., COLT 2019) with the mathematics of denoising. Furthermore, our experiments also show that even without explicit regularization strategies such as weight decay, score smoothing can also result from the implicit regularization effect found in neural networks trained by gradient-based algorithms, which has also been studied by other works such as Vastola (ICLR 2025), Wang and Pehlevan (NeurIPS 2025) and Bonnaire et al. (NeurIPS 2025) with different techniques.

Score smoothing facilitates manifold recovery

In the real world, complex data like high-resolution images live in high-dimensional pixel spaces rather than a simple 1-D world. The vast majority of that space, however, is just random noise that is meaningless to the human eye. Only a small fraction of the data points in that space correspond to recognizable images, and they live in what’s called the data manifold (like a sheet tucked inside a larger space). The shape and location of the data manifold are not known by the model in advance. Thus, image generation can be considered as a task of manifold recovery, where the model needs to infer what the hidden data manifold looks like based on the finite number of training data sampled from it, and then come up with new points on the manifold which will correspond to novel and meaningful images. It turns out that score smoothing is crucial for diffusion models to achieve this.

Remarkably, in multi-dimensional settings, the effect of score smoothing manifests in a direction-dependent manner. Along directions that are parallel (or “tangential”) to the hidden data manifold, it produces a similar slowing-down effect as in the 1-D scenario. However, along directions pointing towards the manifold, the "perfect" score function is already relatively smooth (in fact, just a straight line if the manifold is flat), and further smoothing does not make much difference.

Hence, instead of applying brakes to the particles' flow in every direction (which would stall them in the noisy empty space and result in the final images being blurry), score smoothing does not slow down their convergence toward the manifold, but only reduces their tendency to collapse towards the training data along the tangential directions. In this way, the model achieves a balance between quality and novelty: the images are both realistic looking (because they successfully reached the meaningful data manifold) and new (because they settled into the blank spaces between the original training data points).

In multi-dimensional settings, score smoothing induces an interpolation effect that approximates manifold learning.

Conclusion

Our findings suggest that what we call the “creativity" of diffusion models might actually be a predictable mathematical result. Because neural networks are never "perfectly" sharp, they create bridges that interpolate between known data. In image generation or drug discovery, this could mean the diffusion model doesn't just remember two different cat images or drug molecules it was shown; it explores the space around them to suggest a third, brand-new image or molecular configuration that combines traces of both.

Our work only serves as an initial effort towards elucidating this mechanism, and other researchers have investigated what happens when the data distribution or the neural network architectures grow more complex and in conditional generation tasks. By showing that this behavior is fundamentally rooted in how neural networks learn, we can begin to intentionally build models that are better "interpolators" to ensure they remain creative engines while avoiding the pitfalls of blind memorization. We have also released the code for the numerical experiments used to generate the figures in our paper.

Acknowledgements

We thank Sreenivas Gollapudi and Ravi Kumar for supporting the project as well as Mark Simborg and Kimberly Schwede for helping to prepare this blogpost. We refer the readers to our paper for a discussion of the rich research literature on which our work is built.

Google — Invalid Date

Estimates suggest that billions of wearable devices are now in use, precisely tracking heart rate, movement, skin temperature, blood-oxygen levels, and sleep across days, weeks, and months. This continuous, longitudinal stream of physiology and behavior provides one of the most promising raw materials for preventive, personalized health. Yet turning those low-level signals into meaningful insights remains hard. First, baseline physiology, lifestyle, and health vary enormously from person to person, so a pattern that signals risk in one individual may not in another. Second, the labels needed to train models — confirmed diagnoses, lab results, validated questionnaires — are expensive, slow to collect, and essentially impossible to gather retrospectively. As a result, most wearable health models have been built one outcome at a time, with bespoke, supervised pipelines that target a narrow endpoint and struggle to generalize across the full breadth of human health.

In “Towards a General Intelligence and Interface for Wearable Health Data”, we take a different approach. We introduce SensorFM, a Large Sensor Foundation Model that learns directly from unlabeled wearable data at population scale. Pre-trained on over one trillion minutes of multimodal sensor signals drawn from five million consented participants, SensorFM learns a single, reusable representation of sensed human physiology — one that transfers across cardiovascular, metabolic, sleep, and mental health, as well as lifestyle and demographic factors. To our knowledge, this is the largest and most diverse wearable dataset used to train a model to date.

Learning from a trillion minutes of sensor data

To build the pre-training corpus, we sampled de-identified data from five million people who had consented to the use of their data for health and wellness research, captured between September 2024 and September 2025. The dataset spans more than 100 countries, all 50 U.S. states, and over 20 Fitbit and Pixel Watch device models. From each person we drew several weeks of data, yielding over two billion hours — more than a trillion minutes — of minute-resolution signals.

SensorFM ingests 34 one-minute aggregate features derived from five sensor modalities: photoplethysmography (PPG), accelerometry, electrodermal activity (EDA), skin temperature, and altimetry. Together these capture heart rate and heart-rate variability, blood-oxygen saturation, sleep stages, motion and steps, skin conductance, and temperature over a full 24-hour window.

Rather than relying on labels, SensorFM learns through self-supervised reconstruction, building on the LSM-2 approach and its Adaptive and Inherited Masking (AIM) framework. This is a crucial design choice, because missing and fragmented data (e.g., stretches of time where data is not available) is the norm with wearable devices, caused by a variety of factors such as sensors’ power-cycle, devices coming off the wrist, power saving modes of operation, and sensors switching on and off. Conventional self-supervised methods assume complete, uninterrupted inputs and so are forced to either impute the gaps (which can introduce bias) or discard incomplete windows (which throws away valuable data). AIM takes neither path: it treats real-world missingness as a natural artifact and learns directly from incomplete recordings, combining the tokens inherited from genuine gaps with those artificially masked for the reconstruction objective and treating the two as equivalent. The result is a representation that is missingness-aware by construction. SensorFM does not just tolerate fragmented data, it uses it productively, as the generative results below show.

SensorFM is pre-trained on over a trillion minutes of multimodal sensor data via missing-aware masked reconstruction.

Scaling model and data together pays off

A central question for any foundation model is whether scale translates into capability. We ran a systematic set of scaling experiments, spanning four orders of magnitude in both pre-training data volume (from roughly 2 million to 2 billion sensor-hours) and model size (from 100K to 100M parameters).

The result is a clean, encouraging signal: pre-training loss falls predictably as data and capacity grow, and — crucially — those gains carry over to downstream health tasks. The largest model (SensorFM-B) trained on the full five-million-person corpus reduces reconstruction loss by 31% over the smallest variant, and improves downstream performance by an average 9% performance gain (AUC) on classification tasks and 21% of performance gain (Pearson Coefficient) on regression tasks.

The biggest improvements come from scaling both dimensions at once. Increasing data and capacity in proportion produces near-linear gains in both generative pre-training and discriminative downstream performance — and the curve shows no sign of saturating. Across model variants, SensorFM-B wins on 33 of 35 tasks.

Co-scaling data and model capacity by orders of magnitude yields gains in both pre-training and downstream performance, with no sign of saturation.

One representation, many health domains

To test how general the learned representation really is, we evaluated SensorFM across 35 discriminative health tasks drawn from three independent, Institutional Review Board Approved prospective studies with a total of 13,985 participants. The tasks span six categories: cardiovascular health, metabolic risk, mental health, sleep, demographics, and lifestyle.

To probe the quality of the embeddings directly, we kept the SensorFM encoder frozen and trained only a lightweight linear head on top of it — then compared against supervised baselines trained on engineered features. Here’s what we found:

Broad generalization: Linear probes on SensorFM embeddings outperform the feature-engineered supervised baseline on 34 of 35 tasks, without any task-specific architecture.
Physiology learned implicitly: Adding demographic features (age, sex, etc.) gives a modest boost — but that boost shrinks as the model scales, suggesting larger models implicitly capture physiologically relevant traits during pre-training.
Strength in hard-to-measure conditions: Scaled pre-training is especially valuable for conditions like depression and anxiety, which vary from person to person and leave only faint traces in sensor data. SensorFM appears to learn the individual differences that usually bury such signals and pick out the patterns that carry across people.
Label efficiency: With only a small fraction of labeled examples, SensorFM quickly surpasses both demographic-only and feature-engineered baselines — an important property in healthcare, where high-quality labels are scarce.

Relative performance improvement of linear probing on frozen SensorFM embeddings across discriminative health tasks.

A “classroom” of agents to build prediction heads

A general embedding is only as useful as the effort required to adapt it. Traditionally, turning embeddings into a strong predictor for each new endpoint demands manual feature engineering, architecture selection, and hyperparameter tuning — tedious work that gets harder as the number of tasks grows.

To automate this, we built an agentic “classroom”: a set of collaborating and competing LLM agents that iteratively generate, test, and refine executable code to build prediction heads on the SensorFM embeddings. Across our experiments the system explored more than 30,000 candidate solutions.

The agent-designed heads beat a simple linear probe on 16 of 20 classification tasks and 12 of 15 regression tasks. Two patterns stood out: solution quality improves monotonically over the search, and it scales with the capability of the underlying LLM — more capable models (such as more recent versions of Gemini) produce better solutions, while collaboration between agents helps less capable models close the gap.

A “classroom” of LLM agents iteratively writes, tests, and refines code to build prediction heads on SensorFM embeddings, improving solutions over time.

Grounding a Personal Health Agent

Finally, we asked whether SensorFM is useful end-to-end — as a tool that grounds an AI health coach in a person’s own physiology. We integrated SensorFM into a Personal Health Agent and compared three conditions for generating health summaries from 31 real participant profiles:

Demographics + daily wearable metrics + SensorFM predictions
Demographics + daily wearable metrics + ground-truth measurements
Demographics + daily wearable metrics only (baseline)

A panel of clinicians, blinded to condition, rated the resulting summaries across five rubric dimensions — context, relevance, justifiability, personalization, and potential for harm — producing 1,860 ratings over more than 40 hours of expert evaluation. The findings are striking. Adding SensorFM predictions significantly improved responses over the baseline on every rubric dimension. And there was no statistically significant difference between grounding the agent in SensorFM predictions versus actual ground-truth measurements — meaning the model’s inferences served the agent about as well as the real labels would have.

Using SensorFM as a tool for a Personal Health Agent improves clinician-rated responses.

Conclusion

SensorFM points toward a shift in wearable health research: away from many bespoke, single-outcome models and toward a single, generalist representation of human physiology that can be adapted flexibly, efficiently, and at scale. By learning from over a trillion minutes of unlabeled sensor data, it generalizes across cardiovascular, metabolic, sleep, and mental health; supports label-efficient adaptation and robust daily-metric estimation; can be specialized automatically by an agentic classroom; and can ground a Personal Health Agent in a person’s own signals.

Acknowledgements

We would like to thank our co-authors and collaborators from Google Research, Google DeepMind, and academia for their contributions to this work.

Google — Invalid Date

Vehicle transportation underpins much of modern life, enabling the movement of goods and people, productivity, and economic growth. However, the costs are high: drivers spend an average of 2.6 years of their life on the road, and private cars and vans now account for around 10% of global CO2 emissions. Hence, the efficient use of transportation networks is of paramount importance. Can road traffic routing be managed system-wide the way aviation manages airspace or the internet routes data packets? While ground transportation has historically lacked a physical control tower, digital platforms offer a powerful glimpse into a more coordinated future.

The proliferation of navigation services, connected vehicles, smart cities, and autonomous vehicles all provide opportunities to improve both measurement and optimization of transportation resources. Google Research has already demonstrated the power of infrastructure-level intervention with Project Green Light, which uses AI to optimize city traffic lights. Unfortunately, optimizing vehicle networks has proven challenging. While individual vehicle routing is standard across all the top navigation products, optimizing routing system-wide is not yet present. Although theoretical models for network optimization exist, large-scale empirical validation remains limited, thereby hindering forward progress.

In “Urban congestion relief experiments through routing-app interventions”, published in Nature Cities, we present the first large-scale, real-world study into the use of navigation platforms to improve traffic. We show that coordinating even a small fraction of trips to disperse traffic can measurably improve driving speeds and reduce emissions for the entire city. It also establishes an experimentation framework for evolving from individual trip optimization toward a cooperative routing paradigm that enhances total network efficiency.

Experiment

We ran an experiment in 10 major US cities to demonstrate the effectiveness of targeted low-cost routing interventions in improving overall traffic conditions. For this study, the Google Maps algorithm was modified to prefer alternative routes with similar travel times and segment types, effectively guiding trips away from the pre-selected congested segments.

Over a six month period, we adopted a city-wide switchback (also known as crossover) experimental design, alternating between this treatment and the control (unaltered) routing algorithm over consecutive days to appropriately measure the effect of this intervention. Rather than randomly selecting individual trips, the intervention was applied systematically across the entire city. During “treatment” days, the modified routing guided all trips that encountered the pre-selected congested segments toward alternative routes with similar travel times. Under 2% of observed trips received altered routing recommendations as a result of this experiment.

To set up the experiment, cities were chosen based on the congestion levels and ground truth availability. For each city, we selected roughly 100 road segments based on historical congestion patterns, characterized by recurring bottlenecks or high traffic density during peak demand. The figure below shows one such example.

Within this study, we modify at the routing stage the perceived cost to trips passing through pre-selected segments depicting disproportionately high levels of demand and/or congestion. These modifications reroute trips with similarly costing alternative paths away from these segments, thereby reducing the flow of traffic that would have otherwise been experienced within them.

Results

To quantify the effect of our proposed routing intervention, we employed a hierarchical Bayesian outcome modeling framework for our analysis. This approach, which models parameters at both the aggregate city level and localized hourly level simultaneously, offers a flexible way to capture shared variations without imposing strict constraints. It also enables information sharing between cities and time periods, allowing estimates for a particular city or time to borrow strength from other subgroups' effect estimates.

The study found that even these small interventions led to measurable, statistically significant improvements in traffic conditions. Averaged across cities, we observe a median increase of around 2% in driving speeds on targeted segments, corresponding to a median decrease of 0.5% to 1.0% in fuel consumption rates. Over the much larger set of affected segments, i.e., all segments that were impacted by the intervention, including those to which traffic was redirected either away from or onto, driving speeds increased by around 0.35% on median, and 0.5% when traffic is highest in the morning and afternoon. At the scale and energy demands of the cities considered in this study, this translates to potential savings of thousands of tons of CO₂e emissions per city per year.

Estimated outcomes on trip travel times, speeds, and estimated emissions. Each plot quantifies the posterior probability distribution of outcomes from the intervention, and is represented in terms of percentage changes in speeds or emission rates. We see notable improvements to both targeted and affected segment speeds and fuel consumption rates. Outcomes when computed across all affected segments are understandably more diffuse but still positive, particularly during peak hours.

Improvements in driving speeds and emission rates were both prevalent and statistically significant across the network. These gains were the result of the strategic diversion of vehicles from major bottlenecks; by dispersing this traffic efficiently, the peripheral roads maintained higher average speeds and lower overall emissions, even when absorbing higher volumes of vehicles. This behavior is illustrated in the figure below.

A demonstration of the dispersion of traffic in Atlanta induced by the treatment. Top: Routes on aggregate were diverted away from (blue) the central highway passing through the city and onto (green) a spatially more distributed set of segments primarily spanning the periphery of the region. Bottom: Histogram of net volume changes on individual segments. Indeed, vehicles were dispersed from concentrating on a smaller number of high volume segments to a larger number of segments that each received lower volume increases, resulting in a net benefit to the system.

Conclusion

This research clearly shows that networked navigation technology can be a powerful tool for proactively shaping traffic flow for the benefit of society. By coordinating a small fraction of trips, we can achieve systemic gains that benefit all road users — not just those using a specific app. Notably, both navigation users and non-users share the advantages of decongesting targeted segments, leading to network-wide improvements in travel time and a reduction in CO₂e emissions.

Beyond immediate congestion relief, this work establishes a blueprint for a rigorous, experiment-based approach to traffic management. As smart-city infrastructure matures, the experimental pathway demonstrated here — using connectivity to measure and facilitate system-level changes — can be applied to broader challenges like dynamic signal control and real-time network optimization in complex urban environments. While these results show the potential of relatively simple rerouting, they provide the foundation for a future where cars, infrastructure, and network-aware routing work together to optimize travel efficiency and sustainability for the entire community.

Acknowledgements

This work was conducted in collaboration with Alexandre Bayen, Andrew Tomkins, Theophile Cabannes, Kevin Chen, Yechen Li, Marc Nunkesser, Prem Ramaswami, Eray Turkel, Shoshana Vasserman, and Haizheng Zhang.

Google — Invalid Date

Approximately 500,000 deaths every year are attributed to extreme heat, a crisis intensified by the urban heat island effect, which causes metropolitan areas to warm at double the worldwide average. Earlier this month, record-breaking heat waves across Western Europe pushed temperatures past 40°C (104°F). The prevalence of heat-trapping materials, like dark pavements and roofs, combined with a lack of vegetation, largely drives this localized warming. Heat mitigation measures are critical to reducing this toll, and cool roofs offer a highly cost-effective solution. By increasing rooftop reflectivity (albedo), we can significantly reduce the amount of solar energy absorbed by buildings, ultimately lowering local surface temperatures and protecting vulnerable communities.

To address this, Google Research is building AI-driven tools to help lower city temperatures and keep communities safe. By applying AI to high-resolution satellite and aerial imagery, our Heat Resilience tools help cities quantify the impact of targeted cooling interventions. In 2024, we piloted this approach with 14 cities, providing them with rooftop reflectivity data to identify highly vulnerable neighborhoods and determine where cool roofs would yield the greatest temperature reductions. This data guided critical decisions across several cities, resulting in initiatives such as cool roof ordinances and adaptation plans.

Now, we are scaling this impact. In "Estimating high-resolution albedo for urban applications", published in Nature Communications, we detail our methodology for mapping building-level reflectivity across diverse urban environments. This research bridges the gap between general climate observations and actionable, building-level data. We are also releasing an expanded albedo dataset covering over 50 global cities to empower urban planners worldwide to prioritize cool-roof interventions. This dataset is open and accessible through our new, high-resolution Heat Resilience Earth Engine App.

Our approach

As part of our Google Earth AI collection of geospatial models and datasets to transform planetary information into actionable intelligence, we developed a novel method that fuses Sentinel-2 satellite data with high-resolution (30-cm) satellite imagery (Airbus Pléiades Neo). This highly granular dataset moves beyond neighborhood averages to provide actionable, building-level insights. Importantly, our modeling demonstrates that targeted cool-roof planning using this data could mitigate extreme urban heat by up to 0.5°C (0.9°F) globally, offering a highly effective path forward for city planners.

While satellite-based albedo estimates derived from Sentinel-2 are freely available globally, their 10-meter spatial resolution is insufficient to resolve individual rooftops. To overcome this limitation, our approach uses machine learning models and radiometric calibration techniques to blend the radiometric accuracy and global coverage of Sentinel-2 with the precise spatial detail of commercial imagery. By blending data captured across different wavelengths, we can reconstruct a comprehensive spectral reflectance profile for each urban pixel.

To ensure accuracy, we validated our method against high-resolution airborne hyperspectral measurements collected over Boulder, Colorado. The fused 30-cm albedo maps demonstrated high precision, achieving a root mean square error (RMSE) of just 0.04 relative to the ground-truth data. This breakthrough in granularity enables city planners to move beyond neighborhood-level averages and accurately prioritize individual, large-footprint buildings for targeted cool roof retrofits.

Fusing Sentinel-2 data with commercial imagery improves resolution from 10 meters to 30 centimeters, allowing for building-level albedo mapping. (a) High-resolution (30-cm) true-color commercial satellite imagery. (b) Low-resolution (10-m) Sentinel-2 albedo map. (c) The model-generated, high-resolution (30-cm) fused albedo map. (d) Ground-truth albedo derived from airborne hyperspectral measurements, used for validation

Heat Resilience Earth Engine App

To make this data accessible to decision-makers, we have launched a Heat Resilience Earth Engine App. This platform provides high-resolution rooftop albedo (reflectivity) data to empower proactive municipal planning.

The app features:

Building-level visualization: Albedo data displayed as centroids to identify low-reflectivity surfaces.
Baseline analysis: Tools to help cities understand current reflectivity and monitor changes over time.
Data portability: Functionality to download high-resolution data for local analysis and policy development.
Dynamic zoom: A nested interface that transitions from census-tract aggregates to individual building insights.

Expanded coverage

This release expands our data to 50+ cities across 9 countries. New coverage includes major urban centers in Europe (including London, Athens, Barcelona), Brazil (including Rio de Janeiro and São Paulo), and the United States (including Los Angeles, Austin, and New York City). By providing open access to this building-level albedo data, we aim to help cities accelerate the adoption of reflective surfaces to lower urban surface temperatures.

How to access the data

The Heat Resilience Earth Engine App is now live and available for public use. You can explore the interactive data to visualize rooftop albedo across all 50+ cities included in this release.

For detailed technical documentation and to download the high-resolution datasets for your own analysis, please visit the Heat Resilience site.

Acknowledgements

This research was developed by Google Research in collaboration with the World Resource Institute (WRI).

We thank our collaborators at Google and WRI: Elizabeth J. Wesley (WRI), Salil Banerjee, Vishal Batchu, Aniruddh Chennapragada, Kevin Crossan, Bryce Cronkite-Ratcliff, Ellie Delich, Tristan Goulden (National Ecological Observatory Network), Mansi Kansal, Jonas Kemp, Eric Mackres (WRI), Yael Mayer, Rebecca Milman, John C. Platt, Shruthi Prabhakara, Gautam Prasad, Aaron Bell, Shravya Shetty, Charlotte Stanton, Wayne Sun, and Lucy R. Hutyra.

Google — Invalid Date

Tabular data constitutes the backbone of enterprise data infrastructure and powers a significant fraction of critical predictive machine learning applications. From predicting customer churn to identifying financial fraud, tabular regression and classification tasks are ubiquitous. For years, supervised tree-based algorithms like AdaBoost, XGBoost and random forests, to name a few, have historically dominated this space, offering robust performance on structured data.

However, the lifecycle of deploying these traditional models presents a significant bottleneck. Fitting an XGBoost model to a new dataset is not merely a matter of a single .fit() step; it invariably requires tedious manual effort. Data scientists must invest countless hours into extensive hyperparameter optimization and domain-specific feature engineering just to extract a reliable signal from the raw data.

On the other hand, recent advances in the broader machine learning landscape — particularly the evolution of large language models (LLMs) — have changed how we interact with novel tasks. LLMs have demonstrated the remarkable power of zero-shot prediction through in-context learning (ICL). This technique lets a pretrained model learn a new task by providing examples and instructions in the input context, without updating any underlying model weights.

Today, we introduce TabFM, a foundation model designed specifically for tabular data classification and regression. By framing tabular prediction as an ICL problem, TabFM eliminates the need for manual model training, hyperparameter tuning, and complex feature engineering. We are excited to share how this approach allows users to generate high-quality predictions on previously unseen tables in a single forward pass. TabFM is now available on our Hugging Face and GitHub repos.

How it works

The traditional ML paradigm relies on updating model parameters specific to a given dataset's distribution. In contrast, the ICL paradigm bypasses this completely. Instead of undergoing a traditional training phase for each new task, TabFM takes the entire dataset — comprising both the historical training examples and the target testing rows — as a single unified prompt. The model learns to interpret the relationships between columns and rows directly from this context at inference time.

However, applying ICL to tabular data is not as straightforward as tokenizing natural language. Standard language models process one-dimensional, ordered sequences, but tables are fundamentally two-dimensional and inherently orderless: swapping two rows or two columns does not change the underlying meaning of the data. To effectively process these diverse tabular structures while enabling scalable zero-shot prediction, TabFM synthesizes the strengths of architectures like TabPFN and TabICL into a novel hybrid design. This architecture, visualized below, relies on three key mechanisms:

Alternating row and column attention: First, the raw table is processed through a multilayer attention module. Similar to TabPFN, this step applies alternating attention across both columns (features) and rows (examples). By continuously attending across these two dimensions, the model learns rich representations that natively capture complex feature interactions and dependencies. This deep contextualization effectively performs the heavy lifting that would otherwise require tedious manual feature crafting by data scientists.
Row compression: Following this contextualization, the rich, cross-attended information for each individual row is compressed into a single, dense vector representation.
In-context learning (ICL): Finally, a dedicated Transformer operates on this sequence of compressed embeddings. Adopting the highly efficient approach of TabICL, performing attention over these compressed row vectors — rather than the raw, uncompressed grid — drastically reduces the computation cost. This ensures the prediction step remains highly computationally efficient, even for much larger datasets.

TabFM model architecture.

Training on synthetic data at scale

A typical recipe for building foundation models is to use a high-capacity neural network trained on vast amounts of diverse data. However, a major hurdle in tabular ML is that high-quality, diverse tabular datasets — especially the massive tables required to reflect true industrial data analysis — are critically scarce in the open-source space. Industrial tables often contain proprietary schemas and sensitive information, making them inaccessible for broad pre-training.

Because synthetic tables can be generated to be arbitrarily large, they are effectively the only viable option for pre-training a foundation model at this scale. As a result, TabFM is trained entirely on hundreds of millions of synthetic datasets. These datasets are dynamically generated using structural causal models (SCMs) that incorporate a wide variety of random functions. This massive synthetic generation captures the wide variety of distributions and complex feature relationships prevalent in real-world tabular data. As a result, the model generalizes well to unseen real-world tables, as we demonstrate in our benchmarks below.

Performance and benchmarking

To rigorously test TabFM against existing state-of-the-art methods, we evaluated it on TabArena, a living benchmark system that calculates Elo scores based on head-to-head win rates. This comprehensive evaluation spans 38 classification datasets and 13 regression datasets ranging in size from 700 to 150,000 samples.

As shown in the performance plot below, we benchmarked two distinct configurations of our model:

TabFM: This represents the out-of-the-box capability of the model. Predictions are generated in a single forward pass, requiring no tuning or cross-validation.
TabFM-Ensemble: This configuration pushes performance further by incorporating cross features and SVD (Singular Value Decomposition) features. We compute the optimal weights for a 32-way ensemble using a non-negative least squares solver. For classification tasks, this variant also incorporates Platt scaling as an additional calibration step.

For comprehensive TabArena benchmark results—including detailed per-fold metrics and head-to-head win rates against specific baseline models—please visit our GitHub page.

ELO ratings (↑) for the top 10 models across TabArena classification (upper) and regression (lower). (D) = default; (T+E) = tuned + ensemble. Higher scores denote superior performance.

Conclusion

By reframing tabular prediction as an in-context learning problem, TabFM utilizes a hybrid attention architecture and massive synthetic training data to natively capture complex feature interactions. This approach successfully eliminates the traditional bottlenecks of manual feature engineering, hyperparameter optimization, and repetitive model training, and consistently outperforms heavily tuned, industry-standard supervised algorithms. TabFM brings the out-of-the-box convenience of modern foundation models directly to tabular ML workflows, empowering practitioners to generate highly accurate predictions in a single forward pass.

To make this accessible, TabFM is being integrated directly into Google BigQuery. In the coming weeks, users will be able to perform advanced regression and classification using a simple AI.PREDICT SQL command in BigQuery — no ML expertise required.

Acknowledgements

This project is joint work with Erez Louidor Ilan, Taman Narayan, Shuxin Nie, Rajat Sen, Yichen Zhou, Joe Toth, Deqing Fu and Samet Oymak. We thank Kimberly Schwede for designing the graphics.

Google — Invalid Date

Having powerful Large Language Models (LLMs) right in your pocket is now a reality with on-device models like Gemini Nano and Gemma. This technology enables everyday features on your phone — such as instantly summarizing a flurry of notifications or proofreading an important text message — all without sending your private data off device. But to make these features useful for everyday users, they need to happen very efficiently.

Delivering this kind of speed on a mobile device is a significant challenge. Unlike vast server environments, mobile phones operate under a strict energy budget and hard memory (RAM) limits. Furthermore, standard language models generate text "autoregressively" — meaning they process and output just one word (or token) at a time. This step-by-step process creates a bottleneck, underutilizing the phone's processing power while straining its memory bandwidth, which can ultimately slow down the user experience and drain the battery.

To overcome this bottleneck, we are announcing a new architecture that retrofits Multi-Token Prediction (MTP) onto existing, "frozen" Gemini Nano v3 models. Building on prior approaches like the EAGLE framework and Confident Adaptive Language Modeling (CALM), we designed new architectural components to maximize these efficiency gains specifically for mobile environments. Our recent announcements highlighted accelerating Gemma 4 with MTP and making it available to developers.

Today's article tackles the unique, extreme constraints of edge computing. Recently rolled out to the Pixel 9 and 10 series, this approach acts as an out-of-the-box speedup. For users, this means that features like AI Notification Summaries and Proofread generate text significantly faster and with less energy consumption. For developers, it eliminates a major friction point: delivering high-speed on-device AI without the need to fine-tune separate, memory-heavy drafting models for every new task.

A "late exit" strategy

MTP builds upon the evolution of speculative decoding. In a traditional setup, generating N tokens requires N forward passes of the large model. Speculative decoding decouples this process into two parts:

Draft: a smaller, faster approximation model (the "drafter") generates a short sequence of candidate tokens (e.g., 3 tokens).
Verify: a large model (the "verifier") processes these candidates in parallel. If the candidates match what the large model would have predicted, they are accepted. If not, the system rolls back to the first divergence.

However, this results in some inefficiencies. Running a separate "standalone" drafter model (e.g., 128M parameters) competes for limited RAM. Furthermore, a standalone drafter is "blind" to the main model's rich internal state, predicting next tokens based solely on text history without the semantic context the main model has already computed. MTP addresses these inefficiencies by moving from a standalone architecture to an integrated one. Instead of training a separate small language model to draft tokens, we append a lightweight Transformer head, the MTP head, to the final layers of the main model.

This architecture, which uses a deep exit layer for drafting, leverages the work already performed by the main model’s backbone. The MTP head takes the final high-dimensional activations (hidden states) of the main model and uses them to autoregressively predict a sequence of future tokens.

The frozen backbone advantage

While MTP heads are commonly pre-trained in tandem with the backbone — such as in our recent releases of Gemma 4 models — this is prohibitive when leveraging already-deployed on-device foundation models. Instead, our work focuses on retrofitting the drafter head to operate independently of the pre-training pipeline.

We take a fully trained Gemini Nano v3 model, freeze its weights, and attach a dense transformer stack — the MTP head — to the final layers. We train only these parameters to minimize the prediction error on future tokens. With a frozen backbone, MTP becomes strictly an efficiency optimization, ensuring no degradation in the base model's capabilities or safety alignment.

Because incorrect drafts are discarded during verification, the final output remains bit-for-bit identical to the main model, allowing us to roll out efficiency updates with full backward compatibility.

Zero-copy architecture

While standard MTP implementations optimize for training efficiency by sharing static parameters (like embedding weights) between the main model and the drafter, on-device inference faces a stricter bottleneck: dynamic memory. Even with shared weights, if a drafter processes context independently, it incurs a "double tax" on memory by generating and maintaining its own key-value (KV) cache. Given the limited memory on mobile, avoiding this redundancy is critical.

To solve this, we engineered a zero-copy architecture where the MTP head effectively leverages the main model's state. Instead of maintaining its own history, the MTP head is designed to cross-attend directly to the main model’s frozen KV cache. This allows the drafter to query the "memories" and context already computed by the backbone without duplication.

This design yields two efficiency gains. First, it eliminates drafter prefill latency: by utilizing the existing cache, the head requires no additional time to process the prompt. Second, it reduces the runtime memory footprint. We observed savings of 130MB per instance compared to a standalone drafter by saving drafter embedding lookup tables, prefill dot attention variants, and application specific tuning parameters.

By leveraging the main model’s hidden states and KV cache, the MTP head generates candidate tokens that are verified in parallel by the backbone, eliminating redundant prefill latency and reducing memory usage by up to 130MB.

Unlocking richer representations

In our experiments, we found that MTP drafters consistently produce more accurate token predictions, which results in speedups on Pixel 9 devices of 50% or more[aef552], depending on the task, compared to "standalone drafters" of comparable parameter counts.

This performance gap stems from MTP’s access to richer representations. Unlike standalone drafters that treat the main model as a black box, the MTP head directly utilizes final activations already processed by the larger backbone:

Instruction following: In tasks like summarization or rewriting with complex constraints, MTP significantly outperformed standalone fine-tuned drafters.
Predictable text structures: For tasks with high structural predictability (e.g., smart replies), the MTP head effectively learned the syntactic patterns of the main model, achieving up to a 55% improvement in token acceptance.

Real-world impact

For the deployment of MTP on Pixel 9 and 10 devices, we redesigned the on-device inference stack to handle the complex dependency between the verification and drafting phases.

The results validated the architectural choices. In production workloads, such as AI Notification Summaries and Proofread, MTP correctly predicts an average of nearly two additional tokens per inference pass. Furthermore, fewer verification steps mean less time waking heavy processors, reducing energy consumption and improving battery life.

Gemini Nano token generation impact of MTP vs. app-specific standalone tuned drafter across various Pixel 9 applications.

Future directions

We look forward to integrating MTP on future Pixel devices, as well as exploring alternative architectures — including parallel decoding and paradigms without auxiliary heads — to further drive down draft latency and increase simultaneous token verification under strict mobile constraints.

We are also investigating ways to handle the inherent ambiguity of language generation more efficiently. While standard speculative decoding assumes a single best future path, we are developing techniques that allow the model to explore branching possibilities in parallel. This aims to maximize the probability of accepting long sequences even in uncertain contexts. Furthermore, we are studying verification leniency: relaxing the strict exact token match between draft and verification for specific use cases to bring further efficiencies to the edge.

Acknowledgements

This work is part of our efforts for optimizing on-device LLM efficiency, with Filippo Galgani, Omri Homburger, Pooja Consul, Matthew Markwell, and Vivek Kumar. Certain elements were built on developments from the Gemini team in Google DeepMind: Tal Schuster, Ziwei ji, Ivan Korotkov, and Ganesh Jawahar. We’d also like to extend a big thank you for reviews and valuable feedback and support to Nadav Bar, Utku Evci, Nir Shabat, Joe Zou, and teams in Google Research, Google Deepmind, and Platforms & Devices.

Google — Invalid Date

Modern high-performance database systems and cloud services rely on in-memory caching to keep frequently accessed data in RAM to bypass slow disk operations and deliver the lightning-fast response times users expect. But this performance comes with a cost (literally): high-speed memory is expensive, and some serverless cloud providers charge up to $3 per day for just 1 GiB of memory.

Historically, cache management has been treated as a fixed-resource problem. With regular, fixed-sized caching, engineers allocate a specific amount of memory for the cache and the system uses eviction policies like least recently used (LRU) replacement to decide which data to keep when that space runs out. This leads to a classic “Goldilocks” problem: size the cache too small and performance plummets; size it too large for peak demand, and you waste thousands of dollars on idle memory.

In a paper published at the Conference on Innovative Data Systems Research (CIDR), we introduced linear elastic caching, a new approach designed to minimize the total cost of ownership (TCO) of cache management by dynamically adjusting cache size in response to real-time workloads. Instead of treating memory as a fixed, pre-allocated resource, we treat it as an utility whose cost is linear in both the size of the cached data and the duration for which it is held in the cache. By treating memory footprint as a variable cost that integrates over time, we showed that we can significantly reduce expenses without compromising system performance.

The "ski rental" approach to memory

To solve the challenge of dynamic cache sizing, let’s use the classic ski rental problem. Imagine you’re on a ski trip of unknown length. Each day, you face a choice: rent skis for a small daily fee or buy them for a larger upfront cost and ski for free thereafter. If you knew exactly how many days you would ski, the choice would be easy. But without that knowledge, you need an algorithm to minimize your total spend.

Similarly, in a linear elastic cache, every piece of data faces a comparable dilemma. When a piece of data is accessed, the system must decide between two alternatives:

"Rent" the space: Keep the data in RAM and pay a continuous cost for the memory it occupies.
"Buy" the miss: Evict the data to save memory costs, but risk a "buy" cost (the latency and I/O penalty) if the data is needed again soon.

At the same time, the system cannot optimize for each piece of data independently since the cache has a maximum allocated size (think of a large group of people at a ski resort, where the resort only has a limited number of skis to offer). Our core theoretical contribution proves that we can optimize these two factors — the eviction policy and the "rental" duration — separately. This separation lends itself nicely into a clean practical implementation. We can use a ski rental algorithm to determine the time-to-live (TTL) of a page (analogous to the rental duration). If a page isn’t accessed again before its TTL expires, it is automatically evicted. But if the cache ever becomes physically full, a traditional eviction policy like least recently used (LRU) steps in to manage the space.

Traditional online algorithm design focuses on providing worst-case performance guarantees. For the ski rental problem, the classic “break-even” algorithm is to rent until the accumulated cost equals the purchase price, and then buying the skis. While this approach (and its randomized counterpart) provide solid worst-case guarantees, production workloads are mostly predictable. Data access in systems like Spanner — our globally distributed database — often follows discernible patterns that can be exploited to make better renting decisions.

Testing linear elastic caching

To ensure our theory holds up in the real world, we conducted extensive experiments using two primary sources:

Production workloads: We integrated the system into Spanner.
Public traces: We tested against a variety of publicly available cache traces from industry benchmarks to ensure the results weren't specific to Google’s infrastructure.

Production workloads

We developed a practical algorithm that assigns a time-to-live (TTL) to the cached page on each page request based on the page’s access patterns and costs. Because Spanner handles billions of requests per second, this TTL prediction model has to be incredibly lightweight. We opted for a shallow decision tree that can be translated into a few lines of C++ code. The resulting code is also easily interpretable and provides valuable insights on the workload characteristics. This model considers features such as the size of the data, the cost of a cache miss (when data isn’t in the cache and the system needs to retrieve it from some other, slower system like a disk), and the type of database operation being performed to predict the optimal TTL for each page.

We integrated the elastic caching policy into Spanner's production servers over several months. Compared to a standard fixed-size cache, the results were substantial:

Memory usage: Reduced by 15.5%.
Cache misses: Increased by only 5.5%.
Total cost of ownership (TCO): Reduced by approximately 5%.

Crucially, because the algorithm is "cost-aware," the small increase in cache misses was concentrated on data that is cheap to fetch from storage, meaning the impact on actual I/O costs was a negligible 0.5%.

Public traces

We also evaluated our elastic caching approach using several publicly available cache traces. We used an optimized implementation of the greedy dual size frequency (GDSF) eviction algorithm — a generalization of the well-known LRU policy that allows for pages of different sizes — as a fixed cache size baseline policy.

We considered four variants of elastic caching depending on which ski rental algorithm we used and whether or not we used a machine learned model. Since the available public traces don't have application-level features available for training, we didn’t implement decision trees for prediction. Instead, we developed a simple learning strategy that splits each trace in half and uses the first half for training. For each individual page in the training trace, we computed the best TTL for the page that minimizes the cost over the training trace.

Since the behavior of the cache changes depending on what's initially in the cache, a common practice, known as “warming up”, is to use some prefix of the cache trace to populate the cache but not actually measure performance on it. We warmed up all caches with one day’s worth of requests from the second half of the trace and used the rest for testing and measurements. During the test trace, if we encountered a page that was seen during training, we set the TTL to be the best precomputed TTL for that page. Otherwise, we set the TTL using either the breakeven or randomized policies.

Results

We found that the elastic approach consistently outperformed fixed-size caches across diverse workloads. As the cost of memory increases relative to the cost of a cache miss, the savings provided by elastic caching become even more pronounced.

As the following figures demonstrate, elastic caching policies incur significantly lower total cost by dynamically adapting the cache size to the workload. We also observe that the elastic policies incur a much lower cache miss rate when compared to a fixed size policy at a comparable size.

A plot of total cost (memory + cache misses) incurred by different caching policies against varying cache capacities. As cache capacity increases, the baseline GDSF policy incurs a high cost due to increasing memory costs, while the elastic caching policy adapts the utilized cache size to the working set of the problem and maintains a lower total cost.

A plot of the cache miss rate for different average cache sizes. The chart demonstrates that (variants of) the elastic caching policies consistently maintain a significantly lower cache miss rate compared to a traditional fixed size policy, highlighting the efficiency of dynamically reallocating memory space in real time rather than provisioning for static limits.

Conclusion

Linear elastic caching represents a shift in how we think about cloud infrastructure. By moving away from static peak-load provisioning and toward a dynamic, cost-aware model, we can build systems that are both high-performing and economically efficient.

Our evaluation of these learned ski rental policies across Spanner workloads demonstrates that even small, lightweight ML models can have a massive impact when applied to core infrastructure. As cloud environments continue to offer more granular, pay-as-you-go pricing for resources, elastic strategies will become essential for any large-scale service looking to optimize its global footprint.

Acknowledgements

This represents joint work with Tamas Sarlos (Google) and Ravi Kumar (Google) and was presented at the Conference on Innovative Data Systems Research (CIDR) 2025.

Google — Invalid Date

It is well-established that allowing large language models (LLMs) to generate step-by-step reasoning traces, commonly known as chain-of-thought (CoT), enhances performance on complex tasks. When a model solves difficult math equations, writes software, or answers multi-hop factual questions, breaking the problem down into manageable logical steps is highly effective.

However, the utility of this approach remains unclear for simple, single-hop factual questions. For instance, consider a query like: "What year was Mary Engle Pennington inducted into the National Inventors Hall of Fame?" An LLM either has the fact stored in its parametric memory (knowledge encoded directly into its weights) or it doesn't; no complex arithmetic or logical deduction is required. So why would a reasoning trace help?

In "Thinking to Recall: How Reasoning Unlocks Parametric Knowledge in LLMs”, to be presented at COLM 2026, we investigate this phenomenon. We demonstrate that allowing a model to generate a reasoning trace unlocks correct answers that are otherwise effectively unreachable. To understand why reasoning aids parametric knowledge recall when there are no complex reasoning steps to execute, we conduct a series of hypothesis-driven controlled experiments. Our findings reveal two complementary mechanisms driving this: a computational buffer effect and factual priming.

Probing the knowledge boundary

We first measure the parametric recall capability boundary using the pass@k metric. Instead of only checking one model-generated answer, pass@k checks if the correct fact exists within multiple generated attempts. By evaluating the presence of successful reasoning paths in the model’s output distribution while being less sensitive to their exact ranking, pass@k helps us estimate the potential of reasoning for factual recall, rather than only looking at the current model’s top-1 behavior. To assess the impact of reasoning while controlling for parametric knowledge, we focus on reasoning LLMs (R-LLMs) where reasoning can be enabled or disabled (toggled on or off), and compare pass@k between these two modes. We focus on the Gemini-2.5 (Flash and Pro) and Qwen3-32B models, using two challenging closed-book QA datasets: SimpleQA Verified and EntityQuestions.

The results are surprisingly consistent. When reasoning is enabled, the models successfully recall answers that are virtually unrecoverable when reasoning is off. Importantly, this improvement isn't just because the model is decomposing complex questions. This results from our deliberate focus on datasets containing predominantly simple, single-hop questions.

Pass@𝑘 curves across two closed-book QA datasets and three LLMs, comparing the same models with reasoning enabled (ON) vs reasoning disabled (OFF).

These results raise the question: if the effect does not come from step-by-step reasoning, what reasoning patterns enable the model to retrieve the correct answer?

Mechanism 1: The computational buffer

Our first hypothesis focuses on the mechanics of generation. We take the long-standing hypothesis that generating extra tokens acts as extended computation time by providing additional forward passes, and test it in the new setting of parametric knowledge recall in R-LLMs. Specifically, we hypothesize that models implicitly use these reasoning tokens as a computational buffer to perform latent processing, independent of the actual semantic content being generated.

To test this, we design an experiment that removes all meaningful content from the reasoning trace . We intercept the model's reasoning process and replace its generated trace with a meaningless string "Let me think", repeated over and over until it matches the length of the original reasoning trace. We then let the model predict the final answer conditioned on this dummy text.

Remarkably, conditioning the model on this meaningless trace substantially improves its ability to recall the correct answer compared to the baseline where reasoning is completely turned off. This provides strong evidence that simply giving the model more computational runway helps it refine its internal state and fetch hard-to-reach facts.

Computation buffer effect on Gemini-2.5-Flash. ON Dummy overrides the thinking trace with a short sequence without factual content that is repeated to match the token length of the original trace.

However, this compute-buffer effect has its limits. Pushing the dummy text to longer lengths eventually offers diminishing returns, and it never fully matches the performance of the model's natural reasoning traces. This means that while extra computation helps, the actual content of the thoughts still matters.

Reasoning effectiveness as a function of the input length in tokens when conditioning on dummy reasoning traces. ON Dummy X overrides the reasoning trace with a short dummy sequence which is repeated such that the input length will be X tokens. The reasoning effectiveness metric (Ω) summarizes the pass@k gains across all k values. We define it as a weighted average relative difference in pass@𝑘 between reasoning ON and OFF modes.

Mechanism 2: Factual priming

When we analyze the natural reasoning traces generated for simple factual questions, we notice a common pattern. The models aren't writing out logical proofs; they are surfacing related facts.

In human cognition, there is a concept known as spreading activation, where processing a specific concept primes related concepts in semantic memory, making them easier to retrieve. We hypothesize that language models exhibit a similar generative self-retrieval mechanism, which we call factual priming. By generating facts topically related to the question, the model builds a contextual bridge that facilitates the retrieval of the correct answer.

To test hypotheses, we extract just the concrete facts from the model’s reasoning traces, applying strict filtering to strip away any filler text, search plans, or explicit mentions of the final target answer. We then isolate the effect of the recalled facts, and show that conditioning on a short list of recalled facts recovers most of reasoning’s gains and helps even when reasoning is OFF.

Factual priming effect on Gemini-2.5-Flash. We first extract the facts mentioned during reasoning. ON Facts overrides the models’ original reasoning trace with this short fact list and regenerates the final answer, while OFF Facts runs the model reasoning disabled with the fact list provided as additional input context as part of the prompt.

For example, if asked for the name of the 10th King of Nepal, a reasoning model might first list the previous nine kings. Recalling those first nine acts as a semantic warm-up, priming the network to successfully recall the 10th. The facts themselves are the stepping stones.

An illustration of "factual priming" in action where intermediate factual retrieval (listing the previous nine Kings) primes the model to successfully recall the 10th King of Nepal. The model succeeds to answer correctly with reasoning enabled (ON) while failing without it. It also succeeds when the prediction is conditioned only on a short list of facts recalled during reasoning (ON Facts).

The hallucination trap

While generative self-retrieval is a powerful mechanism, it introduces a fundamental risk. Because the model generates these intermediate facts itself, they might be hallucinated. We thus check how these reasoning-stage errors impact the final answer. To find out, we build a large-scale auditing pipeline using a search-enabled verifier to independently check the correctness of every single intermediate fact generated across hundreds of thousands of reasoning traces.

The audit reveals a distinct pattern. If a reasoning trace contains even a single hallucinated intermediate fact, the model is significantly less likely to arrive at the correct final answer. This suggests that, while effective, the factual priming mechanism might be fragile.

Ratio of correct answers when reasoning traces contain hallucinations (hallucinated) compared to those that do not contain hallucinations (clean).

Building more reliable models

Understanding these mechanisms provides practical avenues for improving model reliability. Because factual priming is effective and hallucinated intermediate facts degrade performance, we can leverage both insights to improve model accuracy.

To evaluate the potential of these insights, we use a test-time selection strategy that generates multiple reasoning trajectories for a single question, retaining only those that contain verifiable, hallucination-free facts. Prioritizing these trajectories considerably improves accuracy. In practice, this prioritization could be implemented during training via process rewards that encourage factually supported intermediate steps.

Expected accuracy under test-time selection criteria based on factual recall and factual correctness.

Conclusion

Our findings highlight that reasoning in language models serves a much broader purpose than just task decomposition or mathematical logic. It acts as a fundamental mechanism for exposing a model's internal memory and expanding its parametric knowledge boundary. These insights open up exciting directions for future research. Knowing that factually accurate reasoning traces yield better answers suggests that training recipes can be further optimized. By utilizing process rewards that specifically encourage factually supported intermediate steps, we might be able to train models that are inherently more reliable and less prone to hallucination. We look forward to seeing how the research community continues to explore the intersections of reasoning, memory, and retrieval.

Acknowledgements

This research was conducted by Zorik Gekhman, Roee Aharoni, Eran Ofek, Mor Geva, Roi Reichart and Jonathan Herzig. We thank Eyal Ben-David and Avinatan Hassidim for reviewing the work and their valuable suggestions.

Google — Invalid Date

Forests are more than just clusters of trees; they are critical systems that sequester carbon, filter water, and support the biodiversity on which humanity depends. As the world strives to mitigate the climate crisis and halt biodiversity loss, increasing forest habitat is a global priority.

The difficulty lies in land use. With a growing population, the demand for food is increasing, and expanding large-scale forests inevitably competes with the agricultural land needed to meet that demand. This tension creates a key challenge: how do we address climate change and halt biodiversity loss without compromising food security or causing "leakage", where conservation in one area inadvertently shifts environmental degradation to another?

Fine-scale woody features, such as hedgerows and shelterbelts woven among our farms, offer a potential solution. They can enhance carbon storage and biodiversity without displacing crops, yet they are often “invisible” to national forest inventories because they are too small for standard satellite detection.

To make these hidden assets visible, we previously released Farmscapes 2020: the first large-scale, high-resolution map to identify overlooked features like hedgerows and linear woodlands across England, in collaboration with the Leverhulme Centre for Nature Recovery at the University of Oxford. While the initial raster (pixel-based) format was a step forward in detection, real-world applications for landscape restoration and carbon accounting require more than pixels. Today, we’re releasing a vectorized dataset that transforms these maps into an actionable inventory of hedgerows, stone walls, and copses. This new resource empowers landowners and conservationists to measure and expand these fine-scale features throughout the UK.

Key landscape features and their primary ecological functions.

Mapping the fabric of the countryside

Moving from a high-resolution raster map to an actionable vector dataset required overcoming technical hurdles at the intersection of spatial topology, semantics, and computational scale.

First, agricultural landscapes present complex spatial topologies. Features are rarely isolated; for example, a hedgerow might border a field or run directly alongside a stone wall, meaning standard single-layer models struggle to represent these overlapping elements. Additionally, processing such a large map requires breaking it into S2-cell tiles (a grid system that flattens our round planet into flat squares on a map), which often results in features being artificially sliced at the tile borders.

Second, there is the question of semantic value. A simple "woody" pixel doesn't distinguish between a forest core, a connective corridor, or an isolated copse. To make the vectorized dataset useful for conservation, we had to find a way to programmatically classify these shapes based on their actual ecological function.

Finally, we faced the problem of computational scale. The sheer size of the high-resolution dataset made standard raster-to-vector operations computationally prohibitive. Processing millions of individual woody features across the entirety of England (an area of over 130,000 km²) required careful data handling to avoid overwhelming traditional systems.

Teaching AI the shape of the countryside

To bridge the gap between pixels and planning, we developed a high-resolution deep-learning framework designed to explicitly map features across the complex patchwork of agricultural land.

Training an AI to recognize specific features of the British countryside like a managed hedgerow requires deep expertise, but we only had a relatively small set of annotated data (~247 km²). To overcome this, we used Remote Sensing Foundations’ (RSF) Vision-Transformer (ViT) Backbone pre-trained on more than 300 million global satellite images. RSF is part of Google Earth AI, our collection of geospatial models and datasets to transform planetary data into actionable insights. By starting with this robust foundation of spatial textures, we fine-tuned the model to recognize the specific nuances of the British landscape with much higher precision.

With this trained model as our foundation, we designed a pipeline to resolve our core spatial, semantic, and scaling challenges.

To handle the layered topology of the countryside, where a stone wall might sit directly beneath the canopy of a hedgerow, we developed a dual-layer labeling system using submeter imagery and 1-meter LiDAR data. This allowed our model to see two things in the same space: (1) the ground-level boundaries (like farmed land or water) and (2) the above-ground features (like the trees and walls that sit on top of them). To fix the artificial slices at tile borders, we developed a scalable algorithm that merges geometries across cells, ensuring every feature is geometrically complete.

We then addressed the semantic challenge. An AI model can easily detect greenery, but it doesn't naturally know the difference between a small cluster of trees and a long, thin hedgerow. To turn the model's raw digital outlines into a useful ecological inventory, we applied a mathematical test called the Polsby–Popper compactness score. By analyzing the physical footprint of each detection, we programmatically categorized the countryside's geometry. We defined woodlands as substantial, contiguous canopies with at least a 30-meter diameter, woody patches as small copses or individual trees, and linear woody features — such as hedgerows and elongated corridors — by their stretched footprints, strictly defined by a compactness score of less than 0.5. This geometric intelligence allowed us to programmatically isolate the long, thin corridors that are so vital for wildlife movement.

Workflow of the landscape features extraction methodology.

Finally, to address the computational bottleneck and scale this analysis nationwide, we leveraged Google Earth Engine. By processing thousands of independent S2 cells in parallel, we bypassed traditional computational limits, allowing us to generate vector geometries for millions of individual features simultaneously. Together, these advancements allow us to turn a raw map into a functional tool for nature recovery.

Looking ahead

While the release of the vectorized dataset is an important step forward, we are already working to further refine the data.

We’re investigating the broader utility of high-precision detection for diverse nature-based solutions, such as supporting the quantification of fine-scale woody features in silvopasture and agrisilviculture systems. This technology could also help identify “leakage” events, ensuring that local gains in carbon and biodiversity are not offset by losses just beyond a project’s boundary. These approaches offer a critical pathway to scale restoration across working lands and address the climate and biodiversity crises without compromising global food security.

By making this data open and accessible, we hope to empower farmers, scientists, and policymakers to protect the small-scale features that make a large-scale difference for our planet.

Learn more about our AI and sustainability efforts by checking out Google Earth AI and Google Earth Engine.