Committee

It’s been a busy and productive year here at MIT Technology Review. We published magazine issues on power, creativity, innovation, bodies, relationships, and security. We hosted 14 exclusive virtual conversations with our editors and outside experts in our subscriber-only series, Roundtables, and held two events on MIT’s campus. And we published hundreds of articles online, following new developments in computing, climate tech, robotics, and more.  As the year winds down, we wanted to give you a chance to revisit a bit of this work with us. Whether we were covering the red-hot rise of artificial intelligence or the future of biotech, these are some of the stories that resonated the most with our readers.  We did the math on AI’s energy footprint. Here’s the story you haven’t heard. Understanding AI’s energy use was a huge global conversation in 2025 as hundreds of millions of people began using generative AI tools on a regular basis. Senior reporters James O’Donnell and Casey Crownhart dug into the numbers and published an unprecedented look at AI’s resource demand, down to the level of a single query, to help us know how much energy and water AI may require moving forward.  We’re learning more about what vitamin D does to our bodies Vitamin D deficiency is widespread, particularly in the winter when there’s less sunlight to drive its production in our bodies. The “sunshine vitamin” is important for bone health, but as senior reporter Jessica Hamzelou reported, recent research is also uncovering surprising new insights into other ways it might influence our bodies, including our immune systems and heart health. What is AI? Senior editor Will Douglas Heaven’s expansive look at how to define AI was published in 2024, but it still managed to connect with many readers this year. He lays out why no one can agree on what AI is—and explains why that ambiguity matters, and how it can inform our own critical thinking about this technology. Ethically sourced “spare” human bodies could revolutionize medicine In this thought-provoking op-ed, a team of experts at Stanford University argue that creating living human bodies that can’t think, don’t have any awareness, and can’t feel pain could shake up medical research and drug development by providing essential biological materials for testing and transplantation. Recent advances in biotechnology now provide a potential pathway to such “bodyoids,” though plenty of technical challenges and ethical hurdles remain.  It’s surprisingly easy to stumble into a relationship with an AI chatbot Chatbots were everywhere this year, and reporter Rhiannon Williams chronicled how quickly people can develop bonds with one. That’s all right for some people, she notes, but dangerous for others. Some folks even describe unintentionally forming romantic relationships with chatbots. This is a trend we’ll definitely be keeping an eye on in 2026.  Is this the electric grid of the future? The electric grid is bracing for disruption from more frequent storms and fires, as well as an uncertain policy and regulatory landscape. And in many ways, the publicly owned utility company Lincoln Electric in Nebraska is an ideal lens through which to examine this shift as it works through the challenges of delivering service that’s reliable, affordable, and sustainable. Exclusive: A record-breaking baby has been born from an embryo that’s over 30 years old This year saw the birth of the world’s “oldest baby”: Thaddeus Daniel Pierce, who arrived on July 26. The embryo he developed from was created in 1994 during the early days of IVF and had been frozen and sitting in storage ever since. The new baby’s parents were toddlers at the time, and the embryo was donated to them decades later via a Christian “embryo adoption” agency.   How these two brothers became go-to experts on America’s “mystery drone” invasion Twin brothers John and Gerald Tedesco teamed up to investigate a concerning new threat—unidentified drones. In 2024 alone, some 350 drones entered airspace over a hundred different US military installations, and many cases went unsolved, according to a top military official. This story takes readers inside the equipment-filled RV the Tedescos created to study mysterious aerial phenomena, and how they made a name for themselves among government officials.  10 Breakthrough Technologies of 2025  Our newsroom has published this annual look at advances that will matter in the long run for over 20 years. This year’s list featured generative AI search, cleaner jet fuel, long-acting HIV prevention meds, and other emerging technologies that our journalists think are worth watching. We’ll publish the 2026 edition of the list on January 12, so stay tuned. (In the meantime, here’s what didn’t make the cut.)  

Google has released FunctionGemma, a specialized version of the Gemma 3 270M model that is trained specifically for function calling and designed to run as an edge agent that maps natural language to executable API actions. But, What is FunctionGemma? FunctionGemma is a 270M parameter text only transformer based on Gemma 3 270M. It keeps the same architecture as Gemma 3 and is released as an open model under the Gemma license, but the training objective and chat format are dedicated to function calling rather than free form dialogue. The model is intended to be fine tuned for specific function calling tasks. It is not positioned as a general chat assistant. The primary design goal is to translate user instructions and tool definitions into structured function calls, then optionally summarize tool responses for the user. From an interface perspective, FunctionGemma is presented as a standard causal language model. Inputs and outputs are text sequences, with an input context of 32K tokens and an output budget of up to 32K tokens per request, shared with the input length. Architecture and training data The model uses the Gemma 3 transformer architecture and the same 270M parameter scale as Gemma 3 270M. The training and runtime stack reuse the research and infrastructure used for Gemini, including JAX and ML Pathways on large TPU clusters. FunctionGemma uses Gemma’s 256K vocabulary, which is optimized for JSON structures and multilingual text. This improves token efficiency for function schemas and tool responses and reduces sequence length for edge deployments where latency and memory are tight. The model is trained on 6T tokens, with a knowledge cutoff in August 2024. The dataset focuses on two main categories: public tool and API definitions tool use interactions that include prompts, function calls, function responses and natural language follow up messages that summarize outputs or request clarification This training signal teaches both syntax, which function to call and how to format arguments, and intent, when to call a function and when to ask for more information. Conversation format and control tokens FunctionGemma does not use a free form chat format. It expects a strict conversation template that separates roles and tool related regions. Conversation turns are wrapped with <start_of_turn>role … <end_of_turn> where roles are typically developer, user or model. Within those turns, FunctionGemma relies on a fixed set of control token pairs <start_function_declaration> and <end_function_declaration> for tool definitions <start_function_call> and <end_function_call> for the model’s tool calls <start_function_response> and <end_function_response> for serialized tool outputs These markers let the model distinguish natural language text from function schemas and from execution results. The Hugging Face apply_chat_template API and the official Gemma templates generate this structure automatically for messages and tool lists. Fine tuning and Mobile Actions performance Out of the box, FunctionGemma is already trained for generic tool use. However, the official Mobile Actions guide and the model card emphasize that small models reach production level reliability only after task specific fine tuning. The Mobile Actions demo uses a dataset where each example exposes a small set of tools for Android system operations, for example create a contact, set a calendar event, control the flashlight and map viewing. FunctionGemma learns to map utterances such as ‘Create a calendar event for lunch tomorrow’ or ‘Turn on the flashlight’ to those tools with structured arguments. On the Mobile Actions evaluation, the base FunctionGemma model reaches 58 percent accuracy on a held out test set. After fine tuning with the public cookbook recipe, accuracy increases to 85 percent. Edge agents and reference demos The main deployment target for FunctionGemma is edge agents that run locally on phones, laptops and small accelerators such as NVIDIA Jetson Nano. The small parameter count, 0.3B, and support for quantization allow inference with low memory and low latency on consumer hardware. Google ships several reference experiences through the Google AI Edge Gallery Mobile Actions shows a fully offline assistant style agent for device control using FunctionGemma fine tuned on the Mobile Actions dataset and deployed on device. Tiny Garden is a voice controlled game where the model decomposes commands such as “Plant sunflowers in the top row and water them” into domain specific functions like plant_seed and water_plots with explicit grid coordinates. FunctionGemma Physics Playground runs entirely in the browser using Transformers.js and lets users solve physics puzzles via natural language instructions that the model converts into simulation actions. These demos validate that a 270M parameter function caller can support multi step logic on device without server calls, given appropriate fine tuning and tool interfaces. Key Takeaways FunctionGemma is a 270M parameter, text only variant of Gemma 3 that is trained specifically for function calling, not for open ended chat, and is released as an open model under the Gemma terms of use. The model keeps the Gemma 3 transformer architecture and 256k token vocabulary, supports 32k tokens per request shared between input and output, and is trained on 6T tokens. FunctionGemma uses a strict chat template with <start_of_turn>role … <end_of_turn> and dedicated control tokens for function declarations, function calls and function responses, which is required for reliable tool use in production systems. On the Mobile Actions benchmark, accuracy improves from 58 percent for the base model to 85 percent after task specific fine tuning, showing that small function callers need domain data more than prompt engineering. The 270M scale and quantization support let FunctionGemma run on phones, laptops and Jetson class devices, and the model is already integrated into ecosystems such as Hugging Face, Vertex AI, LM Studio and edge demos like Mobile Actions, Tiny Garden and the Physics Playground. Check out the Technical details and Model on HF. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post From Gemma 3 270M to FunctionGemma, How Google AI Built a Compact Function Calling Specialist for Edge Workloads appeared first on MarkTechPost.

In this tutorial, we dive into the cutting edge of Agentic AI by building a “Zettelkasten” memory system, a “living” architecture that organizes information much like the human brain. We move beyond standard retrieval methods to construct a dynamic knowledge graph where an agent autonomously decomposes inputs into atomic facts, links them semantically, and even “sleeps” to consolidate memories into higher-order insights. Using Google’s Gemini, we implement a robust solution that addresses real-world API constraints, ensuring our agent stores data and also actively understands the evolving context of our projects. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser !pip install -q -U google-generativeai networkx pyvis scikit-learn numpy import os import json import uuid import time import getpass import random import networkx as nx import numpy as np import google.generativeai as genai from dataclasses import dataclass, field from typing import List from sklearn.metrics.pairwise import cosine_similarity from IPython.display import display, HTML from pyvis.network import Network from google.api_core import exceptions def retry_with_backoff(func, *args, **kwargs): max_retries = 5 base_delay = 5 for attempt in range(max_retries): try: return func(*args, **kwargs) except exceptions.ResourceExhausted: wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1) print(f” Quota limit hit. Cooling down for {wait_time:.1f}s…”) time.sleep(wait_time) except Exception as e: if “429” in str(e): wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1) print(f” Quota limit hit (HTTP 429). Cooling down for {wait_time:.1f}s…”) time.sleep(wait_time) else: print(f” Unexpected Error: {e}”) return None print(” Max retries reached.”) return None print(“Enter your Google AI Studio API Key (Input will be hidden):”) API_KEY = getpass.getpass() genai.configure(api_key=API_KEY) MODEL_NAME = “gemini-2.5-flash” EMBEDDING_MODEL = “models/text-embedding-004″ print(f” API Key configured. Using model: {MODEL_NAME}”) We begin by importing essential libraries for graph management and AI model interaction, while also securing our API key input. Crucially, we define a robust retry_with_backoff function that automatically handles rate limit errors, ensuring our agent gracefully pauses and recovers when the API quota is exceeded during heavy processing. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser @dataclass class MemoryNode: id: str content: str type: str embedding: List[float] = field(default_factory=list) timestamp: int = 0 class RobustZettelkasten: def __init__(self): self.graph = nx.Graph() self.model = genai.GenerativeModel(MODEL_NAME) self.step_counter = 0 def _get_embedding(self, text): result = retry_with_backoff( genai.embed_content, model=EMBEDDING_MODEL, content=text ) return result[’embedding’] if result else [0.0] * 768 We define the fundamental MemoryNode structure to hold our content, types, and vector embeddings in an organized data class. We then initialize the main RobustZettelkasten class, establishing the network graph and configuring the Gemini embedding model that serves as the backbone of our semantic search capabilities. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def _atomize_input(self, text): prompt = f””” Break the following text into independent atomic facts. Output JSON: {{ “facts”: [“fact1”, “fact2”] }} Text: “{text}” “”” response = retry_with_backoff( self.model.generate_content, prompt, generation_config={“response_mime_type”: “application/json”} ) try: return json.loads(response.text).get(“facts”, []) if response else [text] except: return [text] def _find_similar_nodes(self, embedding, top_k=3, threshold=0.45): if not self.graph.nodes: return [] nodes = list(self.graph.nodes(data=True)) embeddings = [n[1][‘data’].embedding for n in nodes] valid_embeddings = [e for e in embeddings if len(e) > 0] if not valid_embeddings: return [] sims = cosine_similarity([embedding], embeddings)[0] sorted_indices = np.argsort(sims)[::-1] results = [] for idx in sorted_indices[:top_k]: if sims[idx] > threshold: results.append((nodes[idx][0], sims[idx])) return results def add_memory(self, user_input): self.step_counter += 1 print(f”n [Step {self.step_counter}] Processing: “{user_input}””) facts = self._atomize_input(user_input) for fact in facts: print(f” -> Atom: {fact}”) emb = self._get_embedding(fact) candidates = self._find_similar_nodes(emb) node_id = str(uuid.uuid4())[:6] node = MemoryNode(id=node_id, content=fact, type=’fact’, embedding=emb, timestamp=self.step_counter) self.graph.add_node(node_id, data=node, title=fact, label=fact[:15]+”…”) if candidates: context_str = “n”.join([f”ID {c[0]}: {self.graph.nodes[c[0]][‘data’].content}” for c in candidates]) prompt = f””” I am adding: “{fact}” Existing Memory: {context_str} Are any of these directly related? If yes, provide the relationship label. JSON: {{ “links”: [{{ “target_id”: “ID”, “rel”: “label” }}] }} “”” response = retry_with_backoff( self.model.generate_content, prompt, generation_config={“response_mime_type”: “application/json”} ) if response: try: links = json.loads(response.text).get(“links”, []) for link in links: if self.graph.has_node(link[‘target_id’]): self.graph.add_edge(node_id, link[‘target_id’], label=link[‘rel’]) print(f” Linked to {link[‘target_id’]} ({link[‘rel’]})”) except: pass time.sleep(1) We construct an ingestion pipeline that decomposes complex user inputs into atomic facts to prevent information loss. We immediately embed these facts and use our agent to identify and create semantic links to existing nodes, effectively building a knowledge graph in real time that mimics associative memory. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def consolidate_memory(self): print(f”n [Consolidation Phase] Reflecting…”) high_degree_nodes = [n for n, d in self.graph.degree() if d >= 2] processed_clusters = set() for main_node in high_degree_nodes: neighbors = list(self.graph.neighbors(main_node)) cluster_ids = tuple(sorted([main_node] + neighbors)) if cluster_ids in processed_clusters: continue processed_clusters.add(cluster_ids) cluster_content = [self.graph.nodes[n][‘data’].content for n in cluster_ids] prompt = f””” Generate a single high-level insight summary from these facts. Facts: {json.dumps(cluster_content)} JSON: {{ “insight”: “Your insight here” }} “”” response = retry_with_backoff( self.model.generate_content, prompt, generation_config={“response_mime_type”: “application/json”} ) if response: try: insight_text = json.loads(response.text).get(“insight”) if insight_text: insight_id = f”INSIGHT-{uuid.uuid4().hex[:4]}” print(f” Insight: {insight_text}”) emb = self._get_embedding(insight_text) insight_node = MemoryNode(id=insight_id, content=insight_text, type=’insight’, embedding=emb) self.graph.add_node(insight_id, data=insight_node, title=f”INSIGHT: {insight_text}”, label=”INSIGHT”, color=”#ff7f7f”) self.graph.add_edge(insight_id, main_node, label=”abstracted_from”) except: continue time.sleep(1) def answer_query(self, query): print(f”n Querying: “{query}””) emb = self._get_embedding(query) candidates = self._find_similar_nodes(emb, top_k=2) if not candidates: print(“No relevant memory found.”) return relevant_context = set() for node_id, score in candidates: node_content = self.graph.nodes[node_id][‘data’].content relevant_context.add(f”- {node_content} (Direct Match)”) for n1 in self.graph.neighbors(node_id): rel = self.graph[node_id][n1].get(‘label’, ‘related’) content = self.graph.nodes[n1][‘data’].content relevant_context.add(f” – linked via ‘{rel}’ to: {content}”) context_text = “n”.join(relevant_context) prompt = f””” Answer based ONLY on context. Question: {query} Context: {context_text} “”” response = retry_with_backoff(self.model.generate_content, prompt) if response: print(f” Agent Answer:n{response.text}”) We implement the cognitive functions of our agent, enabling it to “sleep” and consolidate dense memory clusters into higher-order insights. We also define the query logic that traverses these connected paths, allowing the agent to reason across multiple hops in the graph to answer complex questions. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def show_graph(self): try: net = Network(notebook=True, cdn_resources=’remote’, height=”500px”, width=”100%”, bgcolor=’#222222′, font_color=’white’) for n, data in self.graph.nodes(data=True): color = “#97c2fc” if data[‘data’].type == ‘fact’ else “#ff7f7f” net.add_node(n, label=data.get(‘label’, ”), title=data[‘data’].content, color=color) for u, v, data in self.graph.edges(data=True): net.add_edge(u, v, label=data.get(‘label’, ”)) net.show(“memory_graph.html”) display(HTML(“memory_graph.html”)) except Exception as e:

arXiv:2509.26226v2 Announce Type: replace-cross Abstract: Reinforcement Learning with Verifiable Reward (RLVR) effectively solves complex tasks but demands extremely long context lengths during training, leading to substantial computational costs. While multi-stage training can partially mitigate this, starting with overly short contexts often causes irreversible performance degradation, ultimately failing to reduce overall training compute significantly. In this paper, we introduce **T**hinking-**F**ree **P**olicy **I**nitialization (**TFPI**), a simple yet effective adaptation to RLVR that bridges long Chain-of-Thought (CoT) distillation and standard RLVR. TFPI employs a simple *ThinkFree* operation, explicitly discarding the thinking content via a direct ** append, to reduce token usage during inference. Training with *ThinkFree*-adapted inputs improves performance and lowers token consumption, even in the original slow-thinking mode. Extensive experiments across various benchmarks have shown that TFPI accelerates RL convergence, achieves a higher performance ceiling, and yields more token-efficient reasoning models without specialized rewards or complex training designs. With TFPI only, we train a 4B model to reach 89.0% accuracy on AIME24 and 65.5% on LiveCodeBench using less than 4K H20 hours.

arXiv:2512.20848v1 Announce Type: new Abstract: We present Nemotron 3 Nano 30B-A3B, a Mixture-of-Experts hybrid Mamba-Transformer language model. Nemotron 3 Nano was pretrained on 25 trillion text tokens, including more than 3 trillion new unique tokens over Nemotron 2, followed by supervised fine tuning and large-scale RL on diverse environments. Nemotron 3 Nano achieves better accuracy than our previous generation Nemotron 2 Nano while activating less than half of the parameters per forward pass. It achieves up to 3.3x higher inference throughput than similarly-sized open models like GPT-OSS-20B and Qwen3-30B-A3B-Thinking-2507, while also being more accurate on popular benchmarks. Nemotron 3 Nano demonstrates enhanced agentic, reasoning, and chat abilities and supports context lengths up to 1M tokens. We release both our pretrained Nemotron 3 Nano 30B-A3B Base and post-trained Nemotron 3 Nano 30B-A3B checkpoints on Hugging Face.