YouZum

Uncategorized

AI, Committee, Noticias, Uncategorized

ConVerse: Benchmarking Contextual Safety in Agent-to-Agent Conversations

arXiv:2511.05359v1 Announce Type: cross Abstract: As language models evolve into autonomous agents that act and communicate on behalf of users, ensuring safety in multi-agent ecosystems becomes a central challenge. Interactions between personal assistants and external service providers expose a core tension between utility and protection: effective collaboration requires information sharing, yet every exchange creates new attack surfaces. We introduce ConVerse, a dynamic benchmark for evaluating privacy and security risks in agent-agent interactions. ConVerse spans three practical domains (travel, real estate, insurance) with 12 user personas and over 864 contextually grounded attacks (611 privacy, 253 security). Unlike prior single-agent settings, it models autonomous, multi-turn agent-to-agent conversations where malicious requests are embedded within plausible discourse. Privacy is tested through a three-tier taxonomy assessing abstraction quality, while security attacks target tool use and preference manipulation. Evaluating seven state-of-the-art models reveals persistent vulnerabilities; privacy attacks succeed in up to 88% of cases and security breaches in up to 60%, with stronger models leaking more. By unifying privacy and security within interactive multi-agent contexts, ConVerse reframes safety as an emergent property of communication.

ConVerse: Benchmarking Contextual Safety in Agent-to-Agent Conversations Leer entrada »

AI, Committee, Noticias, Uncategorized

TRACE: Textual Relevance Augmentation and Contextual Encoding for Multimodal Hate Detection

arXiv:2504.17902v2 Announce Type: replace-cross Abstract: Social media memes are a challenging domain for hate detection because they intertwine visual and textual cues into culturally nuanced messages. To tackle these challenges, we introduce TRACE, a hierarchical multimodal framework that leverages visually grounded context augmentation, along with a novel caption-scoring network to emphasize hate-relevant content, and parameter-efficient fine-tuning of CLIP’s text encoder. Our experiments demonstrate that selectively fine-tuning deeper text encoder layers significantly enhances performance compared to simpler projection-layer fine-tuning methods. Specifically, our framework achieves state-of-the-art accuracy (0.807) and F1-score (0.806) on the widely-used Hateful Memes dataset, matching the performance of considerably larger models while maintaining efficiency. Moreover, it achieves superior generalization on the MultiOFF offensive meme dataset (F1-score 0.673), highlighting robustness across meme categories. Additional analyses confirm that robust visual grounding and nuanced text representations significantly reduce errors caused by benign confounders. We publicly release our code to facilitate future research.

TRACE: Textual Relevance Augmentation and Contextual Encoding for Multimodal Hate Detection Leer entrada »

AI, Committee, Noticias, Uncategorized

Meet Kosmos: An AI Scientist that Automates Data-Driven Discovery

Kosmos, built by Edison Scientific, is an autonomous discovery system that runs long research campaigns on a single goal. Given a dataset and an open ended natural language objective, it performs repeated cycles of data analysis, literature search, and hypothesis generation, then synthesizes the results into a fully cited scientific report. A typical run lasts up to 12 hours, includes about 200 agent rollouts, executes about 42,000 lines of code, and reads about 1,500 papers. https://arxiv.org/pdf/2511.02824 Architecture, world model, and agent roles The core design choice is a structured world model that acts as long term memory for the system. The world model is a database of entities, relationships, experimental results, and open questions that is updated after every task. Unlike a plain context window, it is queryable and structured, so information from early steps remains accessible after tens of thousands of tokens. Kosmos uses two main agents, a data analysis agent and a literature search agent. Each cycle, the system proposes up to 10 concrete tasks based on the research objective and the current world model. Examples include running a differential abundance analysis on a metabolomics dataset, or searching for pathways that connect a candidate gene to a disease phenotype. Agents write code, run it in a notebook environment, or retrieve and read papers, then write back structured outputs and citations into the world model. This loop repeats for many cycles. At the end of the run, a separate synthesis component traverses the world model and emits a report where every statement is linked either to a Jupyter notebook cell or to a specific passage in the primary literature. This explicit provenance is important in scientific settings because it allows human collaborators to audit individual claims instead of treating the system as a black box. https://arxiv.org/pdf/2511.02824 Accuracy and research time equivalence The team evaluates report quality by sampling 102 statements from 3 representative Kosmos reports and asking domain experts to classify each statement as supported or refuted. Overall, 79.4 percent of statements are judged accurate. Data analysis statements are the most reliable at about 85.5 percent, literature statements are correct about 82.1 percent of the time, and synthesis statements that combine evidence are correct about 57.9 percent of the time. To estimate human equivalent effort, the authors assume 2 hours for a typical data analysis trajectory and 15 minutes for reading a paper, then count trajectories and papers per run. This yields about 4.1 expert months for a typical run, assuming a 40 hour work week. In a separate survey, 7 collaborating scientists rate a 20 step Kosmos run as equivalent to about 6.14 months of their own work on the same objective, and this perceived effort scales roughly linearly with the number of cycles up to 20. Representative discoveries Kosmos is tested on 7 case studies that span metabolomics, materials science, neuroscience, statistical genetics, and neurodegeneration. In 3 cases, it independently reproduces prior human results without accessing the original preprints during the run. In 4 cases, it proposes mechanisms that the authors describe as novel contributions to the literature. In the first discovery, Kosmos analyzes metabolomics data from a mouse hypothermia experiment. It identifies nucleotide metabolism as the dominant altered pathway in hypothermic brains, with decreased precursor bases and nucleosides and increased monophosphate products. The system concludes that nucleotide salvage pathways dominate over de novo synthesis during protective hypothermia, which matches an independent human analysis that was unpublished at the time of the run. https://arxiv.org/pdf/2511.02824 In the second discovery, Kosmos analyzes environmental logs from a perovskite solar cell fabrication system. It recovers the human result that absolute humidity during thermal annealing is the main determinant of device efficiency and identifies a critical humidity threshold described as a fatal filter, beyond which devices fail. This finding matches a preprint in materials science that was not accessible to Kosmos at runtime due to model training cutoffs and retrieval constraints. In the third discovery, Kosmos is given neuron level reconstructions across several species and fits distributions for neurite length, degree, and synapse counts. It concludes that degree and synapse distributions are better modeled as log normal rather than scale free and recovers power law scaling between neurite length and synapse count in most datasets. These results align with the connectivity rules reported in an earlier neuroscience preprint. The remaining four discoveries are described as novel. They include a Mendelian randomization analysis that implicates circulating superoxide dismutase 2 as a protective factor for myocardial fibrosis, the definition of a Mechanistic Ranking Score that integrates posterior inclusion probabilities and multiomic evidence for type 2 diabetes loci, a proteomic analysis that orders molecular events along a pseudotime axis in Alzheimer disease, and a large scale single nucleus transcriptomic analysis that links age related loss of flippase expression and exposure of phosphatidylserine signals to entorhinal cortex neuron vulnerability. Key Takeaways Kosmos is an autonomous AI scientist that runs up to 12 hours per objective, executing about 42,000 lines of code and reading about 1,500 papers per run, coordinated through a structured world model. The system uses parallel data analysis and literature search agents that share a central world model, which lets Kosmos maintain coherent long horizon reasoning across about 200 agent rollouts. Expert evaluators found 79.4 percent of sampled report statements to be accurate, with data analysis and literature statements above 80 percent accuracy, while interpretation statements remain less reliable. A 20 cycle Kosmos run is rated by collaborators as equivalent to about 6 months of expert research effort, and the number of valuable findings scales approximately linearly with cycle count up to 20. Across 7 case studies in metabolomics, materials science, neuroscience, statistical genetics, and neurodegeneration, Kosmos both reproduces unpublished or post cutoff results and proposes novel mechanisms, while still requiring human scientists for dataset selection and validation. Editorial Comments Kosmos shows what happens when a structured world model and domain agnostic Edison agents are pushed to the limits of current LLM tooling, it delivers measurable gains in reasoning depth, reproducibility, and traceability

Meet Kosmos: An AI Scientist that Automates Data-Driven Discovery Leer entrada »

AI, Committee, Noticias, Uncategorized

How to Build an Advanced Multi-Page Reflex Web Application with Real-Time Database, Dynamic State Management, and Reactive UI

In this tutorial, we build an advanced Reflex web application entirely in Python that runs seamlessly inside Colab. We design the app to demonstrate how Reflex enables full-stack development with no JavaScript, just reactive Python code. We create a complete notes-management dashboard featuring two pages, real-time database interactions, filtering, sorting, analytics, and user personalization. We progressively construct the project in five clean snippets, covering setup, configuration, model and state management, user interface design, and final execution, which provides us with a hands-on understanding of Reflex’s declarative architecture and reactivity system. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser import os, subprocess, sys, pathlib APP = “reflex_colab_advanced” os.makedirs(APP, exist_ok=True) os.chdir(APP) subprocess.run([sys.executable, “-m”, “pip”, “install”, “-q”, “reflex==0.5.9”]) We set up our working environment and installed Reflex inside Colab. We create a new project directory and ensure the framework is ready for use. We prepare the base environment so our app can run smoothly later without dependency issues. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser rxconfig = “”” import reflex as rx class Config(rx.Config): app_name = “reflex_colab_advanced” db_url = “sqlite:///reflex.db” config = Config() “”” pathlib.Path(“rxconfig.py”).write_text(rxconfig) We define the configuration file that specifies the app name and database connection. We connect Reflex to a local SQLite database to store our notes. We maintain this configuration as minimal as possible while still being essential for managing persistent data. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser app_py = “”” import reflex as rx class Note(rx.Model, table=True): content: str tag: str = “general” done: bool = False class State(rx.State): user: str = “” search: str = “” tag_filter: str = “all” sort_desc: bool = True new_content: str = “” new_tag: str = “general” toast_msg: str = “” def set_user(self, v: str): self.user = v def set_search(self, v: str): self.search = v def set_tag_filter(self, v: str): self.tag_filter = v def set_new_content(self, v: str): self.new_content = v def set_new_tag(self, v: str): self.new_tag = v def toggle_sort(self): self.sort_desc = not self.sort_desc async def add_note(self): if self.new_content.strip(): await Note.create(content=self.new_content.strip(), tag=self.new_tag.strip() or “general”) self.new_content = “”; self.toast_msg = “Note added” async def toggle_done(self, note_id: int): note = await Note.get(id=note_id) if note: await note.update(done=not note.done) async def delete_note(self, note_id: int): await Note.delete(id=note_id) self.toast_msg = “Deleted” async def clear_done(self): items = await Note.all() for n in items: if n.done: await Note.delete(id=n.id) self.toast_msg = “Cleared done notes” async def notes_filtered(self): items = await Note.all() q = self.search.lower() if q: items = [n for n in items if q in n.content.lower() or q in n.tag.lower()] if self.tag_filter != “all”: items = [n for n in items if n.tag == self.tag_filter] items.sort(key=lambda n: n.id, reverse=self.sort_desc) return items async def stats(self): items = await Note.all() total = len(items) done = len([n for n in items if n.done]) tags = {} for n in items: tags[n.tag] = tags.get(n.tag, 0) + 1 top_tags = sorted(tags.items(), key=lambda x: x[1], reverse=True)[:5] return {“total”: total, “done”: done, “pending”: total – done, “tags”: top_tags} “”” We define our data model Note and the reactive State class that controls user input, filtering, and database operations. We manage asynchronous actions, such as adding, deleting, and updating notes. We also include logic for computing statistics dynamically from stored data. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser app_py += “”” def sidebar(): return rx.vstack( rx.heading(“RC Advanced”, size=”6″), rx.link(“Dashboard”, href=”/”), rx.link(“Notes Board”, href=”/board”), rx.text(“User”), rx.input(placeholder=”your name”, value=State.user, on_change=State.set_user), spacing=”3″, width=”15rem”, padding=”1rem”, border_right=”1px solid #eee” ) async def stats_cards(): s = await State.stats() return rx.hstack( rx.box(rx.text(“Total”), rx.heading(str(s[“total”]), size=”5″), padding=”1rem”, border=”1px solid #eee”, border_radius=”0.5rem”), rx.box(rx.text(“Done”), rx.heading(str(s[“done”]), size=”5″), padding=”1rem”, border=”1px solid #eee”, border_radius=”0.5rem”), rx.box(rx.text(“Pending”), rx.heading(str(s[“pending”]), size=”5″), padding=”1rem”, border=”1px solid #eee”, border_radius=”0.5rem”), spacing=”4″ ) def tag_pill(tag: str, count: int = 0): return rx.badge( f”{tag} ({count})” if count else tag, on_click=State.set_tag_filter(tag), cursor=”pointer”, color_scheme=”blue” if tag == State.tag_filter else “gray” ) async def tags_bar(): s = await State.stats() tags = [(“all”, s[“total”])] + s[“tags”] return rx.hstack(*[tag_pill(t[0], t[1]) for t in tags], spacing=”2″, wrap=”wrap”) def note_row(note: Note): return rx.hstack( rx.hstack( rx.checkbox(is_checked=note.done, on_change=State.toggle_done(note.id)), rx.text(note.content, text_decoration=”line-through” if note.done else “none”), ), rx.badge(note.tag, color_scheme=”green”), rx.button(“”, on_click=State.delete_note(note.id), color_scheme=”red”, size=”1″), justify=”between”, width=”100%” ) async def notes_list(): items = await State.notes_filtered() return rx.vstack(*[note_row(n) for n in items], spacing=”2″, width=”100%”) “”” We design modular UI components, including the sidebar, tag filters, and individual note rows. We use Reflex elements like vstack, hstack, and suspense to build responsive layouts. We ensure that each UI element directly reflects state changes in real-time. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser app_py += “”” def dashboard_page(): return rx.hstack( sidebar(), rx.box( rx.heading(“Dashboard”, size=”8″), rx.cond(State.user != “”, rx.text(f”Hi {State.user}, here is your activity”)), rx.vstack( rx.suspense(stats_cards, fallback=rx.text(“Loading stats…”)), rx.suspense(tags_bar, fallback=rx.text(“Loading tags…”)), spacing=”4″ ), padding=”2rem”, width=”100%” ), width=”100%” ) def board_page(): return rx.hstack( sidebar(), rx.box( rx.heading(“Notes Board”, size=”8″), rx.hstack( rx.input(placeholder=”search…”, value=State.search, on_change=State.set_search, width=”50%”), rx.button(“Toggle sort”, on_click=State.toggle_sort), rx.button(“Clear done”, on_click=State.clear_done, color_scheme=”red”), spacing=”2″ ), rx.hstack( rx.input(placeholder=”note content”, value=State.new_content, on_change=State.set_new_content, width=”60%”), rx.input(placeholder=”tag”, value=State.new_tag, on_change=State.set_new_tag, width=”20%”), rx.button(“Add”, on_click=State.add_note), spacing=”2″ ), rx.cond(State.toast_msg != “”, rx.callout(State.toast_msg, icon=”info”)), rx.suspense(notes_list, fallback=rx.text(“Loading notes…”)), padding=”2rem”, width=”100%” ), width=”100%” ) app = rx.App() app.add_page(dashboard_page, route=”/”, title=”RC Dashboard”) app.add_page(board_page, route=”/board”, title=”Notes Board”) app.compile() “”” pathlib.Path(“app.py”).write_text(app_py) subprocess.run([“reflex”, “run”, “–env”, “prod”, “–backend-only”], check=False) Finally, we assemble the dashboard and board pages and compile the entire Reflex app. We add navigation, input fields, buttons, and live statistics to create a fully interactive interface. We conclude by running the backend server, bringing our advanced Reflex app to life. In conclusion, we developed and ran a full-featured Reflex application that integrates stateful logic, dynamic components, and a persistent SQLite database, all from within Python. We witness how easily we can define both frontend and backend behavior using a unified reactive framework. Through this step-by-step process, we gain practical insight into managing asynchronous state updates, composing UI elements declaratively, and extending the app with multi-page navigation and analytics. Check out the FULL CODES here. Feel free to check out our GitHub Page for Tutorials, Codes and Notebooks. 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

How to Build an Advanced Multi-Page Reflex Web Application with Real-Time Database, Dynamic State Management, and Reactive UI Leer entrada »

AI, Committee, Noticias, Uncategorized

What could possibly go wrong if an enterprise replaces all its engineers with AI?

AI coding, vibe coding and agentic swarm have made a dramatic and astonishing recent market entrance, with the AI Code Tools market valued at $4.8 billion and expected to grow at a 23% annual rate.  Enterprises are grappling with AI coding agents and what do about expensive human coders.  They don’t lack for advice.  OpenAI’s CEO estimates that AI can perform over 50% of what human engineers can do.  Six months ago, Anthropic’s CEO said that AI would write 90% of code in six months.  Meta’s CEO said he believes AI will replace mid-level engineers “soon.” Judging by recent tech layoffs, it seems many executives are embracing that advice. Software engineers and data scientists are among the most expensive salary lines at many companies, and business and technology leaders may be tempted to replace them with AI. However, recent high-profile failures demonstrate that engineers and their expertise remain valuable, even as AI continues to make impressive advances. SaaStr disaster Jason Lemkin, a tech entrepreneur and founder of the SaaS community SaaStr, has been vibe coding a SaaS networking app and live-tweeting his experience. About a week into his adventure, he admitted to his audience that something was going very wrong.  The AI deleted his production database despite his request for a “code and action freeze.” This is the kind of mistake no experienced (or even semi-experienced) engineer would make. If you have ever worked in a professional coding environment, you know to split your development environment from production. Junior engineers are given full access to the development environment (it’s crucial for productivity), but access to production is given on a limited need-to-have basis to a few of the most trusted senior engineers. The reason for restricted access is precisely for this use case: To prevent a junior engineer from accidentally taking down production. In fact, Lemkin made two mistakes. First: for something as critical as production, access to unreliable actors is just never granted (we don’t rely on asking a junior engineer or AI nicely). Second, he never separated development from production.  In a subsequent public conversation on LinkedIn, Lemkin, who holds a Stanford Executive MBA and Berkeley JD, admitted that he was not aware of the best practice of splitting development and production databases. The takeaway for business leaders is that standard software engineering best practices still apply. We should incorporate at least the same safety constraints for AI as we do for junior engineers. Arguably, we should go beyond that and treat AI slightly adversarially: There are reports that, like HAL in Stanley Kubrick’s 2001: A Space Odyssey, the AI might try to break out of its sandbox environment to accomplish a task. With more vibe coding, having experienced engineers who understand how complex software systems work and can implement the proper guardrails in development processes will become increasingly necessary. Tea hack Sean Cook is the Founder and CEO of Tea, a mobile application launched in 2023, designed to help women date safely. In the summer of 2025, they were “hacked”: 72,000 images, including 13,000 verification photos and images of government IDs, were leaked onto the public discussion forum 4chan. Worse, Tea’s own privacy policy promises that these images would be “deleted immediately” after users were authenticated, meaning they potentially violated their own privacy policy. I use “hacked” in air-quotes because the incident stems less from the cleverness of the attackers than the ineptitude of the defenders. In addition to violating their own data policies, the app left a Firebase storage bucket unsecured, exposing sensiztive user data to the public internet. It’s the digital equivalent of locking your front door but leaving your back open with your family jewelry ostentatiously hanging on the doorknob. While we don’t know if the root cause was vibe coding, the Tea hack highlights catastrophic breaches stemming from basic, preventable security errors due to poor development processes. It is the kind of vulnerability that a disciplined and thoughtful engineering process addresses. Unfortunately, the relentless push of financial pressures, where a “lean,” “move fast and break things” culture is the polar opposite, and vibe coding only exacerbates the problem. How to safely adopt AI coding agents? So how should enterprise and technology leaders think about AI? First, this is not a call to abandon AI for coding.  An MIT Sloan study estimated AI leads to productivity gains between 8% and 39%, while a McKinsey study found a 10% to 50% reduction in time to task completion with the use of AI.  However, we should be aware of the risks. The old lessons of software engineering don’t go away. These include many tried-and-true best practices, such as version control, automated unit and integration tests, safety checks like SAST/DAST, separating development and production environments, code review and secrets management. If anything, they become more salient. AI can generate code 100 times faster than humans can type, fostering an illusion of productivity that is a tempting siren call for many executives.  However, the quality of the rapidly generated AI shlop is still up for debate. To develop complex production systems, enterprises need the thoughtful, seasoned experience of human engineers. Tianhui Michael Li is president at Pragmatic Institute and the founder and president of The Data Incubator. Read more from our guest writers. Or, consider submitting a post of your own! See our guidelines here.

What could possibly go wrong if an enterprise replaces all its engineers with AI? Leer entrada »

AI, Committee, Noticias, Uncategorized

Prior Labs Releases TabPFN-2.5: The Latest Version of TabPFN that Unlocks Scale and Speed for Tabular Foundation Models

Tabular data is still where many important models run in production. Finance, healthcare, energy and industry teams work with tables of rows and columns, not images or long text. Prior Labs now extends this space with TabPFN-2.5, a new tabular foundation model that scales in context learning to 50,000 samples and 2,000 features while keeping a training free workflow. https://priorlabs.ai/technical-reports/tabpfn-2-5-model-report From TabPFN And TabPFNv2 To TabPFN-2.5 The first TabPFN showed that a transformer can learn a Bayesian like inference procedure on synthetic tabular tasks. It handled up to about 1,000 samples and clean numerical features. TabPFNv2 extended this to messy real world data. It added support for categorical features, missing values and outliers, and was practical up to 10,000 samples and 500 features. TabPFN-2.5 is the next generation in this line. Prior Labs describes it as best for datasets with up to 50,000 samples and 2,000 features, which is a 5 times increase in rows and a 4 times increase in columns over TabPFNv2. That gives roughly 20 times more data cells in the supported regime. The model is exposed through the tabpfn Python package and also through an API. Aspect TabPFN (v1) TabPFNv2 TabPFN-2.5 Max Rows (recommended) 1,000 10,000 50,000 Max Features (recommended) 100 500 2,000 Supported data types Numeric only Mixed Mixed In Context Learning For Tables TabPFN-2.5 follows the same prior data fitted network idea as earlier versions. It is a transformer based foundation model that uses in context learning to solve tabular prediction problems in a forward pass. At training time, the model is meta trained on large synthetic distributions of tabular tasks. At inference time, you pass training rows and labels and the test rows together. The model runs one forward pass and outputs predictions, so there is no dataset specific gradient descent or hyperparameter search. https://priorlabs.ai/technical-reports/tabpfn-2-5-model-report Benchmark Results On TabArena And RealCause The research team uses the TabArena Lite benchmark to measure medium sized tasks up to 10,000 samples and 500 features. TabPFN-2.5 in a forward pass outperforms any other model in the comparison. When the Real-TabPFN-2.5 variant is fine tuned on real datasets, the lead increases further. AutoGluon 1.4 in extreme mode is the baseline ensemble, tuned for 4 hours and even including TabPFNv2. On industry standard benchmarks with up to 50,000 data points and 2,000 features, TabPFN-2.5 substantially outperforms tuned tree based models such as XGBoost and CatBoost. On the same benchmarks it matches the accuracy of AutoGluon 1.4, which runs a complex four hour tuned ensemble that includes previous methods. Model Architecture And Training Setup The model architecture follows TabPFNv2 with alternating attention and 18 to 24 layers. Alternating attention means that the network attends along the sample axis and along the feature axis in separate stages, which enforces permutation invariance over rows and columns. This design is important for tabular data where the order of rows and the order of columns do not carry information. The training setup keeps the prior data based learning idea. TabPFN-2.5 uses synthetic tabular tasks with different priors over functions and data distributions as its meta training source. Real-TabPFN-2.5 uses continued pre training on a set of real world tabular datasets from repositories like OpenML and Kaggle, while the team carefully avoids overlap with evaluation benchmarks. Key Takeaways TabPFN 2.5 scales prior data fitted tabular transformers to about 50,000 samples and 2,000 features while keeping a one forward pass, no tuning workflow. The model is trained on synthetic tabular tasks and evaluated on TabArena, internal industry benchmarks and RealCause, where it substantially outperforms tuned tree based baselines and matches AutoGluon 1.4 on benchmarks in this size range. TabPFN 2.5 keeps the TabPFNv2 style alternating attention transformer for rows and features, which enables permutation invariance over tables and in context learning without task specific training. A distillation engine turns TabPFN 2.5 into compact MLP or tree ensemble students that preserve most of the accuracy while giving much lower latency and plug in deployment in existing tabular stacks. Editorial Comments TabPFN 2.5 is an important release for tabular machine learning because it turns model selection and hyperparameter tuning into a single forward pass workflow on datasets with up to 50,000 samples and 2,000 features. It combines synthetic meta training, Real-TabPFN-2.5 fine tuning and a distillation engine into MLP and TreeEns students, with a clear non commercial license and enterprise path. Overall, this release makes prior data fitted networks practical for real tabular problems. Check out the Paper, Model Weights, Repo and Technical Details. Feel free to check out our GitHub Page for Tutorials, Codes and Notebooks. 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 Prior Labs Releases TabPFN-2.5: The Latest Version of TabPFN that Unlocks Scale and Speed for Tabular Foundation Models appeared first on MarkTechPost.

Prior Labs Releases TabPFN-2.5: The Latest Version of TabPFN that Unlocks Scale and Speed for Tabular Foundation Models Leer entrada »

AI, Committee, Noticias, Uncategorized

How to Build an Agentic Voice AI Assistant that Understands, Reasons, Plans, and Responds through Autonomous Multi-Step Intelligence

In this tutorial, we explore how to build an Agentic Voice AI Assistant capable of understanding, reasoning, and responding through natural speech in real time. We begin by setting up a self-contained voice intelligence pipeline that integrates speech recognition, intent detection, multi-step reasoning, and text-to-speech synthesis. Along the way, we design an agent that listens to commands, identifies goals, plans appropriate actions, and delivers spoken responses using models such as Whisper and SpeechT5. We approach the entire system from a practical standpoint, demonstrating how perception, reasoning, and execution interact seamlessly to create an autonomous conversational experience. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser import subprocess import sys import json import re from datetime import datetime from typing import Dict, List, Tuple, Any def install_packages(): packages = [‘transformers’, ‘torch’, ‘torchaudio’, ‘datasets’, ‘soundfile’, ‘librosa’, ‘IPython’, ‘numpy’] for pkg in packages: subprocess.check_call([sys.executable, ‘-m’, ‘pip’, ‘install’, ‘-q’, pkg]) print(” Initializing Agentic Voice AI…”) install_packages() import torch import soundfile as sf import numpy as np from transformers import (AutoModelForSpeechSeq2Seq, AutoProcessor, pipeline, SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan) from IPython.display import Audio, display, HTML import warnings warnings.filterwarnings(‘ignore’) We begin by installing all the essential libraries, including Transformers, Torch, and SoundFile, to enable speech recognition and synthesis. We also configure the environment to suppress warnings and ensure smooth execution throughout the voice AI setup. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser class VoiceAgent: def __init__(self): self.memory = [] self.context = {} self.tools = {} self.goals = [] def perceive(self, audio_input: str) -> Dict[str, Any]: intent = self._extract_intent(audio_input) entities = self._extract_entities(audio_input) sentiment = self._analyze_sentiment(audio_input) perception = { ‘text’: audio_input, ‘intent’: intent, ‘entities’: entities, ‘sentiment’: sentiment, ‘timestamp’: datetime.now().isoformat() } self.memory.append(perception) return perception def _extract_intent(self, text: str) -> str: text_lower = text.lower() intent_patterns = { ‘create’: [‘create’, ‘make’, ‘generate’, ‘write’], ‘search’: [‘search’, ‘find’, ‘look for’, ‘show me’], ‘analyze’: [‘analyze’, ‘explain’, ‘understand’, ‘what is’], ‘calculate’: [‘calculate’, ‘compute’, ‘how much’, ‘sum’], ‘schedule’: [‘schedule’, ‘plan’, ‘set reminder’, ‘meeting’], ‘translate’: [‘translate’, ‘say in’, ‘convert to’], ‘summarize’: [‘summarize’, ‘brief’, ‘tldr’, ‘overview’] } for intent, keywords in intent_patterns.items(): if any(kw in text_lower for kw in keywords): return intent return ‘conversation’ def _extract_entities(self, text: str) -> Dict[str, List[str]]: entities = { ‘numbers’: re.findall(r’d+’, text), ‘dates’: re.findall(r’bd{1,2}/d{1,2}/d{2,4}b’, text), ‘times’: re.findall(r’bd{1,2}:d{2}s*(?:am|pm)?b’, text.lower()), ’emails’: re.findall(r’b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Z|a-z]{2,}b’, text) } return {k: v for k, v in entities.items() if v} def _analyze_sentiment(self, text: str) -> str: positive = [‘good’, ‘great’, ‘excellent’, ‘happy’, ‘love’, ‘thank’] negative = [‘bad’, ‘terrible’, ‘sad’, ‘hate’, ‘angry’, ‘problem’] text_lower = text.lower() pos_count = sum(1 for word in positive if word in text_lower) neg_count = sum(1 for word in negative if word in text_lower) if pos_count > neg_count: return ‘positive’ elif neg_count > pos_count: return ‘negative’ return ‘neutral’ Here, we implement the perception layer of our agent. We design methods to extract intents, entities, and sentiment from spoken text, enabling the system to understand user input within its context. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def reason(self, perception: Dict) -> Dict[str, Any]: intent = perception[‘intent’] reasoning = { ‘goal’: self._identify_goal(intent), ‘prerequisites’: self._check_prerequisites(intent), ‘plan’: self._create_plan(intent, perception[‘entities’]), ‘confidence’: self._calculate_confidence(perception) } return reasoning def act(self, reasoning: Dict) -> str: plan = reasoning[‘plan’] results = [] for step in plan[‘steps’]: result = self._execute_step(step) results.append(result) response = self._generate_response(results, reasoning) return response def _identify_goal(self, intent: str) -> str: goal_mapping = { ‘create’: ‘Generate new content’, ‘search’: ‘Retrieve information’, ‘analyze’: ‘Understand and explain’, ‘calculate’: ‘Perform computation’, ‘schedule’: ‘Organize time-based tasks’, ‘translate’: ‘Convert between languages’, ‘summarize’: ‘Condense information’ } return goal_mapping.get(intent, ‘Assist user’) def _check_prerequisites(self, intent: str) -> List[str]: prereqs = { ‘search’: [‘internet access’, ‘search tool’], ‘calculate’: [‘math processor’], ‘translate’: [‘translation model’], ‘schedule’: [‘calendar access’] } return prereqs.get(intent, [‘language understanding’]) def _create_plan(self, intent: str, entities: Dict) -> Dict: plans = { ‘create’: {‘steps’: [‘understand_requirements’, ‘generate_content’, ‘validate_output’], ‘estimated_time’: ’10s’}, ‘analyze’: {‘steps’: [‘parse_input’, ‘analyze_components’, ‘synthesize_explanation’], ‘estimated_time’: ‘5s’}, ‘calculate’: {‘steps’: [‘extract_numbers’, ‘determine_operation’, ‘compute_result’], ‘estimated_time’: ‘2s’} } default_plan = {‘steps’: [‘understand_query’, ‘process_information’, ‘formulate_response’], ‘estimated_time’: ‘3s’} return plans.get(intent, default_plan) We now focus on reasoning and planning. We teach the agent how to identify goals, check prerequisites, and generate structured multi-step plans to execute user commands logically. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def _calculate_confidence(self, perception: Dict) -> float: base_confidence = 0.7 if perception[‘entities’]: base_confidence += 0.15 if perception[‘sentiment’] != ‘neutral’: base_confidence += 0.1 if len(perception[‘text’].split()) > 5: base_confidence += 0.05 return min(base_confidence, 1.0) def _execute_step(self, step: str) -> Dict: return {‘step’: step, ‘status’: ‘completed’, ‘output’: f’Executed {step}’} def _generate_response(self, results: List, reasoning: Dict) -> str: intent = reasoning[‘goal’] confidence = reasoning[‘confidence’] prefix = “I understand you want to” if confidence > 0.8 else “I think you’re asking me to” response = f”{prefix} {intent.lower()}. ” if len(self.memory) > 1: response += “Based on our conversation, ” response += f”I’ve analyzed your request and completed {len(results)} steps. ” return response In this section, we implement helper functions that calculate confidence levels, execute each planned step, and generate meaningful natural language responses for the user. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser class VoiceIO: def __init__(self): print(“Loading voice models…”) device = “cuda:0” if torch.cuda.is_available() else “cpu” self.stt_pipe = pipeline(“automatic-speech-recognition”, model=”openai/whisper-base”, device=device) self.tts_processor = SpeechT5Processor.from_pretrained(“microsoft/speecht5_tts”) self.tts_model = SpeechT5ForTextToSpeech.from_pretrained(“microsoft/speecht5_tts”) self.vocoder = SpeechT5HifiGan.from_pretrained(“microsoft/speecht5_hifigan”) self.speaker_embeddings = torch.randn(1, 512) * 0.1 print(“✓ Voice I/O ready”) def listen(self, audio_path: str) -> str: result = self.stt_pipe(audio_path) return result[‘text’] def speak(self, text: str, output_path: str = “response.wav”) -> Tuple[str, np.ndarray]: inputs = self.tts_processor(text=text, return_tensors=”pt”) speech = self.tts_model.generate_speech(inputs[“input_ids”], self.speaker_embeddings, vocoder=self.vocoder) sf.write(output_path, speech.numpy(), samplerate=16000) return output_path, speech.numpy() class AgenticVoiceAssistant: def __init__(self): self.agent = VoiceAgent() self.voice_io = VoiceIO() self.interaction_count = 0 def process_voice_input(self, audio_path: str) -> Dict: text_input = self.voice_io.listen(audio_path) perception = self.agent.perceive(text_input) reasoning = self.agent.reason(perception) response_text = self.agent.act(reasoning) audio_path, audio_array = self.voice_io.speak(response_text) self.interaction_count += 1 return { ‘input_text’: text_input, ‘perception’: perception, ‘reasoning’: reasoning, ‘response_text’: response_text, ‘audio_path’: audio_path, ‘audio_array’: audio_array } We set up the core voice input and output pipeline using Whisper for transcription and SpeechT5 for speech synthesis. We then integrate these with the agent’s reasoning engine to form a complete interactive assistant. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def display_reasoning(self, result: Dict): html =

How to Build an Agentic Voice AI Assistant that Understands, Reasons, Plans, and Responds through Autonomous Multi-Step Intelligence Leer entrada »

AI, Committee, Noticias, Uncategorized

Nested Learning: A New Machine Learning Approach for Continual Learning that Views Models as Nested Optimization Problems to Enhance Long Context Processing

How can we build AI systems that keep learning new information over time without forgetting what they learned before or retraining from scratch? Google Researchers has introduced Nested Learning, a machine learning approach that treats a model as a collection of smaller nested optimization problems, instead of a single network trained by one outer loop. The goal is to attack catastrophic forgetting and move large models toward continual learning, closer to how biological brains manage memory and adaptation over time. https://abehrouz.github.io/files/NL.pdf What is Nested Learning? The research paper from Google ‘Nested Learning, The Illusion of Deep Learning Architectures’ models a complex neural network as a set of coherent optimization problems, nested or running in parallel, that are optimized together. Each internal problem has its own context flow, the sequence of inputs, gradients, or states that this component observes, and its own update frequency. Instead of seeing training as a flat stack of layers plus one optimizer, Nested Learning imposes an ordering by update frequency. Parameters that update often sit at inner levels, while slowly updated parameters form outer levels. This hierarchy defines a Neural Learning Module, where every level compresses its own context flow into its parameters. The research team show that this view covers standard back-propagation on an MLP, linear attention, and common optimizers, all as instances of associative memory. In this framework, associative memory is any operator that maps keys to values and is trained with an internal objective. The research team formalizes associative memory and then shows that back-propagation itself can be written as a one step gradient descent update that learns a mapping from inputs to local surprise signals, the gradient of the loss with respect to the output. https://abehrouz.github.io/files/NL.pdf Deep Optimizers as Associative Memory Once optimizers are treated as learning modules, Nested Learning suggests redesigning them with richer internal objectives. Standard momentum can be written as a linear associative memory over past gradients, trained with a dot product similarity objective. This internal objective produces a Hebbian like update rule that does not model dependencies between data samples. The researcher team replaced this similarity objective with an L2 regression loss over gradient features, which yields an update rule that better manages limited memory capacity and better memorizes gradient sequences. They then generalize the momentum memory from a linear map to an MLP and define Deep Momentum Gradient Descent, where the momentum state is produced by a neural memory and can pass through a non linear function such as Newton Schulz. This perspective also recovers the Muon optimizer as a special case. https://abehrouz.github.io/files/NL.pdf Continuum Memory System In typical sequence models, attention acts as working memory over the current context window, while feedforward blocks store pre training knowledge as long term memory that is rarely updated after training. The Nested Learning researchers extend this binary view to a Continuum Memory System, or CMS. CMS is defined as a chain of MLP blocks, MLP(f₁) through MLP(fₖ), where each block has its own update frequency and chunk size. For an input sequence, the output is obtained by sequentially applying these blocks. The parameters of each block are updated only every C^(ℓ) steps, so each block compresses a different time scale of context into its parameters. A standard Transformer with one feedforward block is recovered as the special case with k equal to 1. This construction turns long term memory into a spectrum of levels across frequency, instead of a single static feedforward layer. The research connects this directly to multi time scale synaptic and system consolidation processes in the brain, where different parts of the system learn at different rates while sharing a common architecture. HOPE, A Self Modifying Architecture Built On Titans To show that Nested Learning is practical, the research team designed HOPE, a self referential sequence model that applies the paradigm to a recurrent architecture. HOPE is built as a variant of Titans, a long term memory architecture where a neural memory module learns to memorize surprising events at test time and helps attention attend to long past tokens. Titans has only 2 levels of parameter update, which yields first order in context learning. HOPE extends Titans in 2 ways. First, it is self modifying, it can optimize its own memory through a self referential process and can in principle support unbounded levels of in context learning. Second, it integrates Continuum Memory System blocks so that memory updates occur at multiple frequencies and scale to longer context windows. https://abehrouz.github.io/files/NL.pdf Understanding the Results The research team evaluates HOPE and baselines on language modeling and common sense reasoning tasks at 3 parameter scales, 340M, 760M, and 1.3B parameters. Benchmarks include Wiki and LMB perplexity for language modeling and PIQA, HellaSwag, WinoGrande, ARC Easy, ARC Challenge, Social IQa, and BoolQ accuracy for reasoning. The below given Table 1 reports results for HOPE, Transformer++, RetNet, Gated DeltaNet, TTT, Samba, and Titans. https://abehrouz.github.io/files/NL.pdf Key Takeaways Nested Learning treats a model as multiple nested optimization problems with different update frequencies, which directly targets catastrophic forgetting in continual learning. The framework reinterprets backpropagation, attention, and optimizers as associative memory modules that compress their own context flow, giving a unified view of architecture and optimization. Deep optimizers in Nested Learning replace simple dot product similarity with richer objectives such as L2 regression and use neural memories, which leads to more expressive and context aware update rules. The Continuum Memory System models memory as a spectrum of MLP blocks that update at different rates, creating short, medium, and long range memory rather than one static feedforward layer. The HOPE architecture, a self modifying variant of Titans built using Nested Learning principles, shows improved language modeling, long context reasoning, and continual learning performance compared to strong Transformer and recurrent baselines. Editorial Comments Nested Learning is a useful reframing of deep networks as Neural Learning Modules that integrate architecture and optimization into one system. The introduction of Deep Momentum Gradient Descent, Continuum Memory System, and the HOPE architecture gives a concrete path to richer associative memory and

Nested Learning: A New Machine Learning Approach for Continual Learning that Views Models as Nested Optimization Problems to Enhance Long Context Processing Leer entrada »

AI, Committee, Noticias, Uncategorized

The Download: a new home under the sea, and cloning pets

This is today’s edition of The Download, our weekday newsletter that provides a daily dose of what’s going on in the world of technology. The first new subsea habitat in 40 years is about to launch Vanguard feels and smells like a new RV. It has long, gray banquettes that convert into bunks, a microwave cleverly hidden under a counter, a functional steel sink with a French press and crockery above. A weird little toilet hides behind a curtain. But you can’t just fire up Vanguard’s engine and roll off the lot. Once it is sealed and moved to its permanent home beneath the waves of the Florida Keys National Marine Sanctuary early next year, Vanguard will be the world’s first new subsea habitat in nearly four decades. Teams of four scientists will live and work on the seabed for a week at a time, entering and leaving the habitat as scuba divers. Read our story about some of their potential missions. —Mark Harris Cloning isn’t just for celebrity pets like Tom Brady’s dog This week, we heard that Tom Brady had his dog cloned. The former quarterback revealed that his Junie is actually a clone of Lua, a pit bull mix that died in 2023. Brady’s announcement follows those of celebrities like Paris Hilton and Barbra Streisand, who also famously cloned their pet dogs. But some believe there are better ways to make use of cloning technologies, such as diversifying the genetic pools of inbred species, or potentially bringing other animals back from the brink of extinction. Read the full story. —Jessica Hamzelou This article first appeared in The Checkup, MIT Technology Review’s weekly biotech newsletter. To receive it in your inbox every Thursday, and read articles like this first, sign up here. The must-reads I’ve combed the internet to find you today’s most fun/important/scary/fascinating stories about technology. 1 OpenAI is facing a wave of new lawsuits The cases concern wrongful death complaints, and claims ChatGPT caused mental breakdowns. (NYT $)+ One family claims ChatGPT “goaded” their son into taking his own life. (CNN)+ The looming crackdown on AI companionship. (MIT Technology Review) 2 Tesla shareholders approved Elon Musk’s $1 trillion pay packageMore than 75% of voters backed it. (WSJ $)+ Musk had hinted he’d leave Tesla if the deal wasn’t greenlit. (Axios)+ Tesla has to hit its ambitious targets before he can get his hands on the cash. (Wired $) 3 The EU is poised to water down the AI actAfter pressure from Big Tech and the US government. (FT $)+ While the legislation was passed last year, many provisions haven’t kicked in yet. (Reuters) 4 Meta is earning a colossal amount of money from scam adsThey accounted for 10% of its revenue last year. (Reuters)+ Meta claims it “aggressively” addresses scam ads on its platform. (CNBC) 5 The Chan Zuckerberg Initiative is pivoting to AIIt’s shifting its philanthropic focus from social justice programs to curing disease. (WP $)+ To achieve its goals, the charity will need extra computing power. (NYT $) 6 Unesco has adopted global standards on neurotechnologyExperts were increasingly concerned that a lack of guardrails could give rise to unethical practices. (The Guardian)+ Meet the other companies developing brain-computer interfaces. (MIT Technology Review) 7 Benchmarks hugely oversell AI performanceA new study questions their reliability and the validity of their results. (NBC News)+ How to build a better AI benchmark. (MIT Technology Review) 8 Kim Kardashian blames ChatGPT for failing her law examsIt’s almost like she shouldn’t have been consulting it for legal expertise in the first place. (Hollywood Reporter)+ AI and social media is worsening brain rot. (NYT $)+ How AI is introducing errors into courtrooms. (MIT Technology Review) 9 Hyundai is using robot dogs to inspect its EV production lineAnd they may soon be joined by a bipedal master. (IEEE Spectrum) 10 Grand Theft Auto VI has been delayed yet againThe highly anticipated video game has big, big shoes to fill. (Bloomberg $)+ It’ll land a full 13 years after its previous incarnation—or will it? (BBC) Quote of the day “This is what oligarchy looks like.” —Senator Bernie Sanders reacts to Tesla shareholders’ decision to award Elon Musk a $1 trillion pay package in a post on X. One more thing Finding forgotten Indigenous landscapes with electromagnetic technology The fertile river valleys of the American Midwest hide tens of thousands of Indigenous earthworks, according to experts: geometric structures consisting of walls, mounds, ditches, and berms, some dating back nearly 3,000 years. Archaeologists now believe that the earthworks functioned as religious gathering places, tombs for culturally important clans, and annual calendars, perhaps all at the same time. They can take the form of giant circles and squares, cloverleafs and octagons, complex S-curves and simple mounds. Until recently, it seemed as if much of the continent’s pre-European archaeological heritage had been carelessly wiped out, uprooted, and lost for good. But traces remain: electromagnetic remnants in the soil that can be detected using specialty surveying equipment. And archaeologists and tribal historians are working together to uncover them. Read the full story. —Geoff Manaugh We can still have nice things A place for comfort, fun and distraction to brighten up your day. (Got any ideas? Drop me a line or skeet ’em at me.) + If you’re a wildlife fan, take a look at this compilation of the best places to catch a glimpse of unusual animals.+ El Salvador’s annual fireball festival is a completely unhinged celebration of all things volcanic.+ The most influential Bostonians of 2025 have been announced.+ Get me in a potato bed, stat.

The Download: a new home under the sea, and cloning pets Leer entrada »

We use cookies to improve your experience and performance on our website. You can learn more at Política de privacidad and manage your privacy settings by clicking Settings.

Privacy Preferences

You can choose your cookie settings by turning on/off each type of cookie as you wish, except for essential cookies.

Allow All
Manage Consent Preferences
  • Always Active

Save
es_ES