YouZum

Uncategorized

AI, Committee, Actualités, Uncategorized

Mistral AI Releases Voxtral TTS: A 4B Open-Weight Streaming Speech Model for Low-Latency Multilingual Voice Generation

Mistral AI has released Voxtral TTS, an open-weight text-to-speech model that marks the company’s first major move into audio generation. Following the release of its transcription and language models, Mistral is now providing the final ‘output layer’ of the audio stack, positioning itself as a direct competitor to proprietary voice APIs in the developer ecosystem. Voxtral TTS is more than just a synthetic voice generator. It is a high-performance, modular component designed to be integrated into real-time voice workflows. By releasing the model under a CC BY-NC license, Mistral team continues its strategy of enabling developers to build and deploy frontier-grade capabilities without the constraints of closed-source API pricing or data privacy limitations. https://arxiv.org/pdf/2603.25551 Architecture: The 4B Parameter Hybrid Model While many recent developments in text-to-speech have focused on massive, resource-intensive architectures, Voxtral TTS is built with a focus on efficiency. The model features 4B parameters, categorized as a lightweight model by modern frontier standards. This parameter count is distributed across a hybrid architecture designed to solve the common trade-offs between generation speed and audio naturalness. The system comprises three primary components: Transformer Decoder Backbone: A 3.4B parameter module based on the Ministral architecture that handles the text understanding and predicts semantic representations of speech. Flow-Matching Acoustic Transformer: A 390M parameter module that converts those semantic representations into detailed acoustic features. Neural Audio Codec: A 300M parameter decoder that maps the acoustic features back into a high-fidelity audio waveform. By separating the ‘meaning’ of the speech (semantic) from the ‘texture’ of the voice (acoustic), Voxtral TTS maintains long-range consistency while delivering the fine-grained nuances required for lifelike interaction. Performance: 70ms Latency and High Throughput In the context of production-grade AI, latency is the defining constraint. Mistral has optimized Voxtral TTS for low-latency streaming inference, making it suitable for conversational agents and real-time translation. The model achieves a 70ms model latency for a typical 10-second voice sample and 500-character input. This speed is critical for reducing the perceived delay in voice-first applications, where even small pauses can disrupt the flow of human-machine interaction. Furthermore, the model boasts a high Real-Time Factor (RTF) of approximately 9.7x. This means the system can synthesize audio nearly ten times faster than it is spoken. For developers, this throughput translates to lower compute costs and the ability to handle high-concurrency workloads on standard inference hardware. Global Reach: 9 Languages and Dialect Accuracy Voxtral TTS is natively multilingual, supporting 9 languages out of the gate: English, French, German, Spanish, Dutch, Portuguese, Italian, Hindi, and Arabic. The training objective for the model goes beyond simple phonetic translation. Mistral has emphasized the model’s ability to capture diverse dialects, recognizing the subtle shifts in cadence and prosody that distinguish regional speakers. This technical precision makes the model an effective tool for global applications—from international customer support to localized content creation—where a generic, ‘flattened’ accent often fails to pass the human test. Adaptive Voice Adaptation One of the standout features for AI devs is the model’s ease of voice adaptation. Voxtral TTS supports zero-shot and few-shot voice cloning, allowing it to adapt to a new voice using as little as 3 seconds of reference audio. This capability allows for the creation of consistent brand voices or personalized user experiences without the need for extensive fine-tuning. Because the model uses a factorized representation, it can apply the characteristics of a reference voice (timbre, tone, and pitch) to any generated text while maintaining the correct linguistic prosody of the target language. Benchmarks: A Challenge to the Proprietary Giants Mistral’s evaluations focus on how Voxtral TTS stacks up against the current industry leaders in synthetic speech, specifically ElevenLabs. In human preference tests conducted by native speakers, Voxtral TTS demonstrated significant gains in naturalness and expressivity. Vs. ElevenLabs Flash v2.5: Voxtral TTS achieved a 68.4% win rate in multilingual voice cloning evaluations. Vs. ElevenLabs v3: The model achieved parity or higher scores in speaker similarity, proving that an open-weight model can effectively match the fidelity of the most advanced proprietary flagship voices. These benchmarks suggest that for many enterprise use cases, the performance gap between open-source tools and high-cost APIs has effectively closed. https://arxiv.org/pdf/2603.25551 Deployment and Integration Voxtral TTS is designed to function as part of a comprehensive Audio Intelligence stack. It integrates natively with Voxtral Transcribe, creating an end-to-end speech-to-speech (S2S) pipeline. For AI developers building on local or private cloud infrastructure, the model’s small footprint is a significant advantage. Mistral’s team has confirmed that the model is efficient enough to run on standard smartphone and laptop hardware once quantized. This ‘edge-readiness’ allows for a new class of private, offline applications, from secure corporate assistants to on-device accessibility tools. Specification Metric Model Size 4B Parameters Latency (10s voice / 500 chars) 70ms Real-Time Factor (RTF) ~9.7x Supported Languages 9 Reference Audio Needed 3 – 30 seconds License CC BY-NC Key Takeaways High-Efficiency 4B Parameter Model: Voxtral TTS is a frontier open-weight model with a 4B parameter footprint, utilizing a hybrid architecture that combines auto-regressive semantic generation with flow-matching for acoustic details. Ultra-Low 70ms Latency: Optimized for real-time applications, the model achieves a 70ms model latency for a typical 10-second voice sample (500-character input) and an impressive Real-Time Factor (RTF) of approximately 9.7x. Superior Multilingual Performance: The model supports 9 languages (English, French, German, Spanish, Dutch, Portuguese, Italian, Hindi, and Arabic) and outperformed ElevenLabs Flash v2.5 with a 68.4% win rate in human preference tests for multilingual voice cloning. Instant Voice Adaptation: Developers can achieve high-fidelity voice cloning with as little as 3 seconds of reference audio, enabling zero-shot cross-lingual adaptation where a speaker’s unique identity is preserved across different languages. Full Audio Stack Integration: Designed as the ‘output layer’ of a unified audio intelligence pipeline, it plugs natively into Voxtral Transcribe to create low-latency, end-to-end speech-to-speech workflows. Check out the Paper, Model Weight and Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 120k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Mistral

Mistral AI Releases Voxtral TTS: A 4B Open-Weight Streaming Speech Model for Low-Latency Multilingual Voice Generation Lire l’article »

AI, Committee, Actualités, Uncategorized

Chroma Releases Context-1: A 20B Agentic Search Model for Multi-Hop Retrieval, Context Management, and Scalable Synthetic Task Generation

In the current AI landscape, the ‘context window’ has become a blunt instrument. We’ve been told that if we simply expand the memory of a frontier model, the retrieval problem disappears. But as any AI professionals building RAG (Retrieval-Augmented Generation) systems knows, stuffing a million tokens into a prompt often leads to higher latency, astronomical costs, and a ‘lost in the middle’ reasoning failure that no amount of compute seems to fully solve. Chroma, the company behind the popular open-source vector database, is taking a different, more surgical approach. They released Context-1, a 20B parameter agentic search model designed to act as a specialized retrieval subagent. Rather than trying to be a general-purpose reasoning engine, Context-1 is a highly optimized ‘scout.’ It is built to do one thing: find the right supporting documents for complex, multi-hop queries and hand them off to a downstream frontier model for the final answer. The Rise of the Agentic Subagent Context-1 is derived from gpt-oss-20B, a Mixture of Experts (MoE) architecture that Chroma has fine-tuned using a combination of Supervised Fine-Tuning (SFT) and Reinforcement Learning (RL) via CISPO (a staged curriculum optimization). The goal isn’t just to retrieve chunks; it’s to execute a sequential reasoning task. When a user asks a complex question, Context-1 doesn’t just hit a vector index once. It decomposes the high-level query into targeted subqueries, executes parallel tool calls (averaging 2.56 calls per turn), and iteratively searches the corpus. For AI professionals, the architectural shift here is the most important takeaway: Decoupling Search from Generation. In a traditional RAG pipeline, the developer manages the retrieval logic. With Context-1, that responsibility is shifted to the model itself. It operates inside a specific agent harness that allows it to interact with tools like search_corpus (hybrid BM25 + dense search), grep_corpus (regex), and read_document. The Killer Feature: Self-Editing Context The most technically significant innovation in Context-1 is Self-Editing Context. As an agent gathers information over multiple turns, its context window fills up with documents—many of which turn out to be redundant or irrelevant to the final answer. General models eventually ‘choke’ on this noise. Context-1, however, has been trained with a pruning accuracy of 0.94. Mid-search, the model reviews its accumulated context and proactively executes a prune_chunks command to discard irrelevant passages. This ‘soft limit pruning’ keeps the context window lean, freeing up capacity for deeper exploration and preventing the ‘context rot’ that plagues longer reasoning chains. This allows a specialized 20B model to maintain high retrieval quality within a bounded 32k context, even when navigating datasets that would typically require much larger windows. Building the ‘Leak-Proof’ Benchmark: context-1-data-gen To train and evaluate a model on multi-hop reasoning, you need data where the ‘ground truth’ is known and requires multiple steps to reach. Chroma has open-sourced the tool they used to solve this: the context-1-data-gen repository. The pipeline avoids the pitfalls of static benchmarks by generating synthetic multi-hop tasks across four specific domains: Web: Multi-step research tasks from the open web. SEC: Finance tasks involving SEC filings (10-K, 20-F). Patents: Legal tasks focusing on USPTO prior-art search. Email: Search tasks using the Epstein files and Enron corpus. The data generation follows a rigorous Explore → Verify → Distract → Index pattern. It generates ‘clues’ and ‘questions’ where the answer can only be found by bridging information across multiple documents. By mining ‘topical distractors’—documents that look relevant but are logically useless—Chroma ensures that the model cannot ‘hallucinate’ its way to a correct answer through simple keyword matching. Performance: Faster, Cheaper, and Competitive with GPT-5 The benchmark results released by Chroma are a reality check for the ‘frontier-only’ crowd. Context-1 was evaluated against 2026-era heavyweights including gpt-oss-120b, gpt-5.2, gpt-5.4, and the Sonnet/Opus 4.5 and 4.6 families. Across public benchmarks like BrowseComp-Plus, SealQA, FRAMES, and HotpotQA, Context-1 demonstrated retrieval performance comparable to frontier models that are orders of magnitude larger. The most compelling metrics for AI devs are the efficiency gains: Speed: Context-1 offers up to 10x faster inference than general-purpose frontier models. Cost: It is approximately 25x cheaper to run for the same retrieval tasks. Pareto Frontier: By using a ‘4x’ configuration—running four Context-1 agents in parallel and merging results via reciprocal rank fusion—it matches the accuracy of a single GPT-5.4 run at a fraction of the compute. The ‘performance cliff’ identified isn’t about token length alone; it’s about hop-count. As the number of reasoning steps increases, general models often fail to sustain the search trajectory. Context-1’s specialized training allows it to navigate these deeper chains more reliably because it isn’t distracted by the ‘answering’ task until the search is concluded. https://www.trychroma.com/research/context-1 https://www.trychroma.com/research/context-1 Key Takeaways The ‘Scout’ Model Strategy: Context-1 is a specialized 20B parameter agentic search model (derived from gpt-oss-20B) designed to act as a retrieval subagent, proving that a lean, specialized model can outperform massive general-purpose LLMs in multi-hop search. Self-Editing Context: To solve the problem of ‘context rot,’ the model features a pruning accuracy of 0.94, allowing it to proactively discard irrelevant documents mid-search to keep its context window focused and high-signal. Leak-Proof Benchmarking: The open-sourced context-1-data-gen tool uses a synthetic ‘Explore → Verify → Distract’ pipeline to create multi-hop tasks in Web, SEC, Patent, and Email domains, ensuring models are tested on reasoning rather than memorized data. Decoupled Efficiency: By focusing solely on retrieval, Context-1 achieves 10x faster inference and 25x lower costs than frontier models like GPT-5.4, while matching their accuracy on complex benchmarks like HotpotQA and FRAMES. The Tiered RAG Future: This release champions a tiered architecture where a high-speed subagent curates a ‘golden context’ for a downstream frontier model, effectively solving the latency and reasoning failures of massive, unmanaged context windows. Check out the Repo and Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 120k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Chroma Releases Context-1: A 20B Agentic Search Model for Multi-Hop Retrieval, Context Management, and Scalable Synthetic Task Generation appeared first on

Chroma Releases Context-1: A 20B Agentic Search Model for Multi-Hop Retrieval, Context Management, and Scalable Synthetic Task Generation Lire l’article »

AI, Committee, Actualités, Uncategorized

An Implementation of IWE’s Context Bridge as an AI-Powered Knowledge Graph with Agentic RAG, OpenAI Function Calling, and Graph Traversal

In this tutorial, we implement IWE: an open-source, Rust-powered personal knowledge management system that treats markdown notes as a navigable knowledge graph. Since IWE is a CLI/LSP tool designed for local editors. We build a realistic developer knowledge base from scratch, wire up wiki-links and markdown links into a directed graph, and then walk through every major IWE operation: fuzzy search with find, context-aware retrieval with retrieve, hierarchy display with tree, document consolidation with squash, statistics with stats, and DOT graph export for visualization. We then go beyond the CLI by integrating OpenAI to power IWE-style AI transforms: summarization, link suggestion, and todo extraction, directly against our knowledge graph. Finally, we construct a full agentic RAG pipeline where an AI agent navigates the graph using function-calling tools, performs multi-hop reasoning across interconnected documents, identifies knowledge gaps, and even generates new notes that slot into the existing structure. Copy CodeCopiedUse a different Browser import subprocess, sys def _install(pkg): subprocess.check_call([sys.executable, “-m”, “pip”, “install”, “-q”, pkg]) _install(“openai”) _install(“graphviz”) import re, json, textwrap, os, getpass from collections import defaultdict from dataclasses import dataclass, field from typing import Optional from datetime import datetime try: from google.colab import userdata OPENAI_API_KEY = userdata.get(“OPENAI_API_KEY”) if not OPENAI_API_KEY: raise ValueError print(” Loaded OPENAI_API_KEY from Colab secrets.”) except Exception: OPENAI_API_KEY = getpass.getpass(” Enter your OpenAI API key: “) print(” API key received.”) os.environ[“OPENAI_API_KEY”] = OPENAI_API_KEY from openai import OpenAI client = OpenAI(api_key=OPENAI_API_KEY) print(“n” + “=” * 72) print(” IWE Advanced Tutorial — Knowledge Graph + AI Agents”) print(“=” * 72) @dataclass class Section: level: int title: str content: str children: list = field(default_factory=list) @dataclass class Document: key: str title: str raw_content: str sections: list = field(default_factory=list) outgoing_links: list = field(default_factory=list) tags: list = field(default_factory=list) created: str = “” modified: str = “” class KnowledgeGraph: def __init__(self): self.documents: dict[str, Document] = {} self.backlinks: dict[str, set] = defaultdict(set) _WIKI_LINK = re.compile(r”[[([^]|]+)(?:|([^]]+))?]]”) _MD_LINK = re.compile(r”[([^]]+)](([^)]+))”) _HEADER = re.compile(r”^(#{1,6})s+(.+)”, re.MULTILINE) _TAG = re.compile(r”#([a-zA-Z][w/-]*)”) def _extract_links(self, text: str) -> list[str]: links = [] for match in self._WIKI_LINK.finditer(text): links.append(match.group(1).strip()) for match in self._MD_LINK.finditer(text): target = match.group(2).strip() if not target.startswith(“http”): target = target.replace(“.md”, “”) links.append(target) return links def _parse_sections(self, text: str) -> list[Section]: sections = [] parts = self._HEADER.split(text) i = 1 while i < len(parts) – 1: level = len(parts[i]) title = parts[i + 1].strip() body = parts[i + 2] if i + 2 < len(parts) else “” sections.append(Section(level=level, title=title, content=body.strip())) i += 3 return sections def _extract_tags(self, text: str) -> list[str]: tags = set() for line in text.split(“n”): if line.strip().startswith(“#”) and ” ” in line.strip(): stripped = re.sub(r”^#{1,6}s+.*”, “”, line) for m in self._TAG.finditer(stripped): tags.add(m.group(1)) else: for m in self._TAG.finditer(line): tags.add(m.group(1)) return sorted(tags) def add_document(self, key: str, content: str) -> Document: sections = self._parse_sections(content) title = sections[0].title if sections else key links = self._extract_links(content) tags = self._extract_tags(content) now = datetime.now().strftime(“%Y-%m-%d %H:%M”) doc = Document( key=key, title=title, raw_content=content, sections=sections, outgoing_links=links, tags=tags, created=now, modified=now, ) self.documents[key] = doc for target in links: self.backlinks[target].add(key) return doc def get(self, key: str) -> Optional[Document]: return self.documents.get(key) def find(self, query: str, roots_only: bool = False, limit: int = 10) -> list[str]: q = query.lower() scored = [] for key, doc in self.documents.items(): score = 0 if q in doc.title.lower(): score += 10 if q in doc.raw_content.lower(): score += doc.raw_content.lower().count(q) if q in key.lower(): score += 5 for tag in doc.tags: if q in tag.lower(): score += 3 if score > 0: scored.append((key, score)) scored.sort(key=lambda x: -x[1]) results = [k for k, _ in scored[:limit]] if roots_only: results = [k for k in results if not self.backlinks.get(k)] return results def retrieve(self, key: str, depth: int = 1, context: int = 1, exclude: set = None) -> str: exclude = exclude or set() parts = [] if context > 0: parents_of = list(self.backlinks.get(key, set()) – exclude) for p in parents_of[:context]: pdoc = self.get(p) if pdoc: parts.append(f”[CONTEXT: {pdoc.title}]n{pdoc.raw_content[:300]}…n”) exclude.add(p) doc = self.get(key) if not doc: return f” Document ‘{key}’ not found.” parts.append(doc.raw_content) exclude.add(key) if depth > 0: for link in doc.outgoing_links: if link not in exclude: child = self.get(link) if child: parts.append(f”n—n[LINKED: {child.title}]n”) parts.append( self.retrieve(link, depth=depth – 1, context=0, exclude=exclude) ) return “n”.join(parts) def tree(self, key: str, indent: int = 0, _visited: set = None) -> str: _visited = _visited if _visited is not None else set() doc = self.get(key) if not doc: return “” prefix = ” ” * indent + (“└─ ” if indent else “”) if key in _visited: return f”{prefix}{doc.title} ({key}) (circular ref)” _visited.add(key) lines = [f”{prefix}{doc.title} ({key})”] for link in doc.outgoing_links: if self.get(link): lines.append(self.tree(link, indent + 1, _visited)) return “n”.join(lines) def squash(self, key: str, visited: set = None) -> str: visited = visited or set() doc = self.get(key) if not doc or key in visited: return “” visited.add(key) parts = [doc.raw_content] for link in doc.outgoing_links: child_content = self.squash(link, visited) if child_content: parts.append(f”n{‘─’ * 40}n”) parts.append(child_content) return “n”.join(parts) def stats(self) -> dict: total_words = sum(len(d.raw_content.split()) for d in self.documents.values()) total_links = sum(len(d.outgoing_links) for d in self.documents.values()) orphans = [k for k in self.documents if not self.backlinks.get(k) and not self.documents[k].outgoing_links] all_tags = set() for d in self.documents.values(): all_tags.update(d.tags) return { “total_documents”: len(self.documents), “total_words”: total_words, “total_links”: total_links, “unique_tags”: len(all_tags), “tags”: sorted(all_tags), “orphan_notes”: orphans, “avg_words_per_doc”: total_words // max(len(self.documents), 1), } def export_dot(self, highlight_key: str = None) -> str: lines = [‘digraph KnowledgeGraph {‘, ‘ rankdir=LR;’, ‘ node [shape=box, style=”rounded,filled”, fillcolor=”#f0f4ff”, ‘ ‘fontname=”Helvetica”, fontsize=10];’, ‘ edge [color=”#666666″, arrowsize=0.7];’] for key, doc in self.documents.items(): label = doc.title[:30] color = ‘#ffe4b5’ if highlight_key == key else ‘#f0f4ff’ lines.append(f’ “{key}” [label=”{label}”, fillcolor=”{color}”];’) for key, doc in self.documents.items(): for link in doc.outgoing_links: if link in self.documents: lines.append(f’ “{key}” -> “{link}”;’) lines.append(“}”) return “n”.join(lines) print(“n Section 1 complete — KnowledgeGraph class defined.n”) We install the required dependencies, securely accept the OpenAI API key through Colab secrets or a password prompt, and initialize the OpenAI client. We then define the three foundational data classes, Section, Document, and KnowledgeGraph, that mirror IWE’s arena-based graph architecture where every markdown file is a node and every link is a directed edge. We implement the full suite of IWE CLI operations on the

An Implementation of IWE’s Context Bridge as an AI-Powered Knowledge Graph with Agentic RAG, OpenAI Function Calling, and Graph Traversal Lire l’article »

AI, Committee, Actualités, Uncategorized

Not Just Understanding, But Evolving: The All-New Self-Evolving JiuwenClaw Makes Its Debut

Over the past year, AI agents have evolved from merely answering questions to attempting to get real tasks done. However, a significant bottleneck has emerged: while most agents may appear intelligent during a conversation, they often ‘drop the ball’ when it comes to executing real-world tasks. Whether it’s an office workflow that breaks when requirements change, or a content creation task that feels like starting from scratch with every edit, the issue isn’t a lack of model intelligence—it’s the lack of sustained execution capability. Recently, the openJiuwen community released JiuwenClaw. It doesn’t aim to be the “most conversational” agent; instead, it focuses on a more critical question: Can an AI agent take a task from start to finish? I. A Watershed Moment for AI Agents: Who Can Truly Complete Complex Tasks? 1. Dynamic Office Scenarios: Adapting to Change, Not Just Steps In a typical Excel task, a user might start by organizing a table, then suddenly ask to remove duplicates, then add a summary, and finally change the output format. Traditional agents often treat every change as a brand-new task, losing context and repeating work. JiuwenClaw acts as a true “executor”: Supports task interruption, insertion, reordering, and removal. Maintains focus on the goal despite changes. Provides a visible, controllable, and adjustable execution process. This corresponds to its first core capability: Intelligent Task Planning: Not simply breaking down steps but continuously managing task status and priorities. When faced with complex inputs—task additions, interruptions, modifications—JiuwenClaw precisely understands intentions, intelligently schedules, and completes every goal methodically. 2. Content Creation: Overcoming the Iterative Refinement Challenge In real-world content creation, the workflow is inherently iterative—involving title brainstorming, tone adjustments, structural reorganization, and localized rewrites. The primary failure mode for traditional agents is Contextual Amnesia: with every minor edit, the agent effectively “resets the session,” losing the subtle nuances of the previous draft. JiuwenClaw disrupts this pattern by maintaining multi-layered Contextual Integrity: Granular Edit Understanding: It identifies which specific layer (structure vs. tone) is being modified. Style & Structure Preservation: It maintains consistency across multiple iterations. Continuous Progression: It builds upon the existing draft rather than generating from scratch. This seamless experience is powered by the synergy of two core architectural innovations: (1) Hierarchical Memory System A three-layer architecture (stable identity layer, long-term background layer, dynamic trajectory layer) allows memory to accumulate and dynamically iterate with usage, enabling the AI assistant to remember your preferences and context, becoming more like a trusted old friend over time. (2) Intelligent Context Slimming Proprietary context offloading technology automatically compresses redundant information while retaining key context, ensuring Agents run stably for extended periods, avoiding Token explosions and significantly reducing usage costs. The Result: A definitive answer to the “Stability vs. Duration” trade-off—enabling long-horizon tasks that are both memory-accurate and computationally sustainable. (3) Real-World Automation: Bridging the Gap with “Environmental Realism” The market is saturated with browser-based agents, but most are relegated to “toy demos.” They suffer from a critical flaw: they operate in isolated, “clean” virtual browsers. In real-world deployments, this creates a context gap. Without an existing login state, active Cookies, or user identity headers, every interaction is treated as a “stranger login.” This triggers aggressive anti-bot measures, frequent CAPTCHAs, and ultimately, a near-zero success rate for complex automation. JiuwenClaw takes a pragmatic, Engineering-First Approach: directly taking over the local browser environment, automatically acquiring logged-in accounts, browser Cookies, local cache, and other Profile information, bypassing verification codes and repeated logins to execute tasks in real business systems. Automation is only useful if it works in the messy, authenticated environments of the real world. JiuwenClaw bridges the gap between a “mock-up” and a reliable production tool. II. The Key Differentiator: Can Agents Evolve and Become Smarter? The fundamental limitation of most current AI agents is their static nature—their capabilities are essentially “frozen” the moment they go live. Tool Failure: Results in a simple error log and nothing more. User Correction: Ignored; the same mistake is repeated in the next session. Skill Deployment: Once coded, the logic remains rigid and unchanging. JiuwenClaw disrupts this pattern by introducing a critical architectural mechanism: Autonomous Skill Evolution: Powered by the openJiuwen Self-Evolution Framework, JiuwenClaw autonomously refines its own Skills. When a tool call fails or when the user provides negative feedback (e.g., “That’s incorrect,” or “Try a different approach”), the system proactively logs the execution error and feedback. It then performs a root cause analysis (RCA) to generate targeted optimization strategies. In essence, JiuwenClaw establishes a high-fidelity Execution-to-Learning Closed Loop: Execution → Failure → Learning → Optimization → Re-execution This paradigm shift means the agent is no longer a static collection of tools, but a continuously evolving system that grows more aligned with user intent through every interaction. III.  Integration into Daily Workflows: AI Agents Enter the Real World The fundamental barrier for many agents is not raw capability, but accessibility within native user scenarios. Most agents remain isolated silos, detached from where the actual work happens. JiuwenClaw solves this issue through a critical architectural design: Multi-Channel Seamless Access: It natively supports Huawei Celia (Xiao Yi), Telegram, WhatsApp, Feishu (Lark), and Web. This enables users to trigger their dedicated AI assistant from any environment. Data Sovereignty: By supporting Private Deployment, it eliminates concerns over data privacy and cross-border data flow, ensuring a zero-friction enterprise adoption. This design shifts the paradigm: the agent is no longer a destination you visit (like a standalone website), but a persistent layer embedded within daily communication and professional workflows. IV. JiuwenClaw is More than Just an Agent When we synthesize these capabilities, a clear Architectural Hierarchy emerges. JiuwenClaw isn’t just a monolithic tool; it is a multi-layered execution engine: Layer JiuwenClaw’s Solution Entry Layer Multi-platform access for real-world usage scenarios. Execution Layer Task planning to ensure workflow continuity. Stability Layer Context management + Memory system for long-haul tasks. Evolution Layer Autonomous evolution to get smarter with every use. The convergence of these four layers signals a fundamental strategic shift: AI agents are evolving from “dialogue-based systems” to “high-fidelity execution systems.” V. Industry Shift: From “Chat-Centric” to “Execution-Centric” AI Over the past two years, the AI sector has been dominated by a “Turing Test” obsession: Who is smarter? Who sounds more human? Who scores higher on

Not Just Understanding, But Evolving: The All-New Self-Evolving JiuwenClaw Makes Its Debut Lire l’article »

AI, Committee, Actualités, Uncategorized

NVIDIA AI Unveils ProRL Agent: A Decoupled Rollout-as-a-Service Infrastructure for Reinforcement Learning of Multi-Turn LLM Agents at Scale

NVIDIA researchers introduced ProRL AGENT, a scalable infrastructure designed for reinforcement learning (RL) training of multi-turn LLM agents. By adopting a ‘Rollout-as-a-Service’ philosophy, the system decouples agentic rollout orchestration from the training loop. This architectural shift addresses the inherent resource conflicts between I/O-intensive environment interactions and GPU-intensive policy updates that currently bottleneck agent development. The Core Problem: Tight Coupling Multi-turn agent tasks involve interacting with external environments, such as code repositories or operating systems, via iterative tool use. Many existing frameworks—including SkyRL, VeRL-Tool, Agent Lightning, rLLM, and GEM—embed rollout control directly within the training process. This tight coupling leads to two primary limitations: Conflicting System Requirements: Rollouts are I/O-bound, requiring sandbox creation, long-lived tool sessions, and asynchronous coordination. Training is GPU-intensive, centered on forward/backward passes and gradient synchronization. Running both in one process causes interference and reduces hardware efficiency. Maintenance Barriers: Embedding rollout logic in the trainer makes it difficult to migrate to different training backends or support new runtime environments without re-implementing the execution pipeline. https://arxiv.org/pdf/2603.18815 System Design: Rollout-as-a-Service ProRL AGENT operates as a standalone HTTP service that manages the full rollout lifecycle. The RL trainer interacts with the server solely through an API, remaining agnostic to the underlying rollout infrastructure. Three-Stage Asynchronous Pipeline To maximize throughput, the server orchestrates rollouts through an asynchronous three-stage ‘assembly line’: INIT: Initialization workers spin up sandbox containers and configure tools. RUN: Rollout workers drive the multi-turn agent loop and collect trajectories. EVAL: Evaluation workers score results against ground truth to produce reward signals. By assigning each stage to an independent worker pool, ProRL AGENT allows phases to overlap across different jobs, preventing slow evaluations (such as full test suite executions) from stalling the rollout process. https://arxiv.org/pdf/2603.18815 HPC-Compatible Sandboxing and Optimized Tools ProRL AGENT utilizes Singularity for its sandbox infrastructure. Unlike Docker-based platforms, Singularity allows rootless execution, which is required for deployment on shared HPC clusters managed by Slurm. The system includes several optimizations to reduce tool execution latency, which often dominates total rollout time: Efficient Bash: Replaces tmux-based terminal multiplexing with a ptyprocess-based direct pseudo-terminal, reducing shell command latency from 0.78s to 0.42s. Direct IPython API: Connects to persistent kernels via an in-process API instead of network gateways, removing networking overhead. Unix Domain Sockets (UDS): Replaces TCP loopback for communication between the agent and the execution server inside the container to shave off additional latency. Advanced Features for Scalable RL The infrastructure introduces mechanisms to improve training stability and hardware utilization: Load Balancing and Prefix Cache Reuse The server manages a pool of LLM inference backends (e.g., vLLM) using a min-heap keyed by assignment counts. When a task is assigned, all subsequent calls within that task are routed to the same backend. This strategy maximizes prefix cache reuse, reducing inference time across multiple agent turns. Token-in/Token-out Communication To eliminate re-tokenization drift—where the token sequence generated during rollout differs from what is used during training—ProRL AGENT uses token IDs as the canonical representation throughout the entire process. Log-probabilities and IDs are propagated unchanged from the inference backend to the trainer. Optimized DAPO Implementation The system supports Dynamic Sampling Policy Optimization (DAPO), which filters out ‘non-informative’ prompts that yield uniform rewards. ProRL AGENT uses an asynchronous replenishment mechanism to maintain maximum throughput, terminating redundant active jobs early once the target number of informative prompts is reached. Experimental Results on SWE-Bench Verified The system was validated using Qwen3 models across multiple scales. ProRL AGENT consistently improved performance compared to reproduced baselines. Model Scale Reproduced Baseline ProRL Agent (RL) Qwen3-4B 14.8 21.2 Qwen3-8B 9.6 18.0 Qwen3-14B 15.4 (reproduced baseline) 23.6 Note: The reported prior result for SkyRL-Agent-14B-v0 was 21.6. In addition to software engineering, the system demonstrated generality in STEM, Math, and Code domains, showing steady reward growth during RL training. Scalability tests confirmed that rollout throughput increases near-linearly as compute nodes are added. Key Takeaways Architectural Decoupling: ProRL Agent treats the full agentic rollout lifecycle—including environment initialization, tool execution, and reward scoring—as an independent HTTP service, separating I/O-intensive tasks from GPU-intensive policy training. Significant Performance Gains: This infrastructure enabled the Qwen3-8B model to nearly double its performance on the SWE-Bench Verified benchmark (from 9.6% to 18.0%), while the Qwen3-14B model improved from 15.4% to 23.6%. System Latency Reductions: Targeted optimizations, such as replacing tmux with ptyprocess for shell execution, reduced action latency from 0.78s to 0.42s, contributing to near-linear throughput scaling across compute nodes. Elimination of Tokenization Drift: The framework utilizes a token-in/token-out communication pipeline, ensuring that the exact token IDs generated during rollout are passed to the trainer without the risk of lossy re-tokenization. HPC-Native Deployment: By using Singularity instead of Docker, ProRL Agent supports rootless execution and native Slurm integration, allowing large-scale agent training on shared high-performance computing clusters. Check out the Paper and Repo. Also, feel free to follow us on Twitter and don’t forget to join our 120k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post NVIDIA AI Unveils ProRL Agent: A Decoupled Rollout-as-a-Service Infrastructure for Reinforcement Learning of Multi-Turn LLM Agents at Scale appeared first on MarkTechPost.

NVIDIA AI Unveils ProRL Agent: A Decoupled Rollout-as-a-Service Infrastructure for Reinforcement Learning of Multi-Turn LLM Agents at Scale Lire l’article »

AI, Committee, Actualités, Uncategorized

A woman’s uterus has been kept alive outside the body for the first time

“Think of this as a human body,” says Javier González. In front of me is essentially a metal box on wheels. Standing at around a meter in height, it reminds me of a stainless-steel counter in a restaurant kitchen. It is covered in flexible plastic tubing—which act as veins and arteries—connecting a series of transparent containers, the organs of this machine. What makes it extra special is the role of the cream-colored tub that sits on its surface. Ten months ago, González, a biomedical scientist who developed the device with his colleagues at the Carlos Simon Foundation, carefully placed a freshly donated human uterus in the tub. The team connected it to the device’s tubes and pumped in modified human blood. The device kept the uterus alive for a day—a new feat that could represent the first step to the long-term maintenance of uteruses outside the human body. The work has not yet been published.  The team members want to keep donated human uteruses alive long enough to see a full menstrual cycle. They hope this will help them study diseases of the uterus and learn more about how embryos burrow their way into the organ’s lining at the start of a pregnancy. They also hope that future iterations of their device might one day sustain the full gestation of a human fetus. The machine is technically called PUPER, which stands for “preservation of the uterus in perfusion.” But González’s colleague Xavier Santamaria says the team has adopted a nickname for it: “We call it ‘Mother.’” The organ in the machine González and Santamaria, medical vice president of the Carlos Simon Foundation, demonstrated how the device might work when I visited the foundation in Valencia, Spain, earlier this month (although it held no organs on that day).  Both are interested in learning more about implantation, the moment at which an embryo attaches itself to the lining of a uterus—essentially, the very first moment of pregnancy. The foundation’s founder and director, Carlos Simon, believes it’s a sticking point in IVF: Scientists have made many improvements to the technology over the years, but the failure of embryos to implant underlies plenty of unsuccessful IVF cycles, he says. Being able to carefully study how the process works in a real, living organ might give the team a better idea of how to prevent those failures. JESS HAMZELOU JAVIER GONZALES/CARLOS SIMON FOUNDATION Javier González demonstrates the perfusion machine. A previous iteration of the device kept a sheep’s uterus (right) alive for a day. The team took inspiration from advances in technologies designed to maintain donated organs for transplantation. In recent years, researchers around the world have created devices that deliver nutrients and filter waste so that organs can survive longer after being removed from donors’ bodies. The main goal here is to buy time. A human organ might last only a matter of hours outside the body, so a transplant may require frantic preparation for the recipient, sometimes in the middle of the night. With a little more time, doctors could find better donor-patient matches and potentially test the quality of donated organs. This approach is called normothermic or machine perfusion, and it is already being used clinically for some liver, kidney, and heart transplants. The team at the Carlos Simon Foundation built a similar machine for uteruses. A blood bag hangs on one side. From there, blood is ferried via plastic tubing to a pump, which functions as the heart. The pump shunts the blood through an oxygenator, which adds oxygen and removes carbon dioxide as the lungs would in a human body. The blood is warmed and passed through sensors that monitor the levels of glucose and oxygen, along with other factors. It passes through a “kidney” to remove waste. And finally the blood reaches the uterus, hooked up to its own plastic “arteries” and “veins.” The organ itself sits at a tilt, just as in the body, and is kept in a humid environment to stay moist. Mother’s first uterus The team first began testing an early prototype of the device with sheep uteruses around four years ago. That meant carting the machine to an animal research center in Zaragoza, around 200 miles away. Over the course of the preliminary study, veterinary surgeons removed the uteruses of six sheep and hooked them up to the machine. They kept each uterus alive for a day, using blood from the same animals. After the sheep experiments, the researchers carted their machine back to Valencia and modified it to achieve its current incarnation, “Mother.” They started working with a local hospital that performed hysterectomies. And in May last year, they were offered their first human uterus. The team needed to be quick. “You need to put [the uterus in the machine] within a couple of hours, maximum, of the extraction,” says Santamaria. He and his colleagues also needed to connect the uterus’s blood vessels to the tubing delicately, taking care to avoid any blockages (clotting is a major challenge in organ perfusion). The organ was hooked up to human blood obtained from a blood bank. It seemed to work—at least temporarily. “We kept it alive for one day,” says Santamaria. “As a proof of concept, it is impressive,” says Keren Ladin, a bioethicist who has focused on organ transplantation and perfusion at Tufts University. “These are early days.” It might not sound like much, but 24 hours is a long time for an organ to be out of the body. Maintaining a donated uterus for that long could expand the options for uterus transplant, a fairly new procedure offered to some people who want to be pregnant but don’t have a functional uterus, says Gerald Brandacher, professor of experimental and translational transplant surgery at the Medical University of Innsbruck in Austria. “It is better than what we currently have, because we have only a couple of hours,” he says. So far, most uterus transplants have been planned operations involving organs from living donors.

A woman’s uterus has been kept alive outside the body for the first time Lire l’article »

AI, Committee, Actualités, Uncategorized

OMIND: Framework for Knowledge Grounded Finetuning and Multi-Turn Dialogue Benchmark for Mental Health LLMs

arXiv:2603.25105v1 Announce Type: new Abstract: Large Language Models (LLMs) have shown remarkable capabilities for complex tasks, yet adaptation in medical domain, specifically mental health, poses specific challenges. Mental health is a rising concern globally with LLMs having large potential to help address the same. We highlight three primary challenges for LLMs in mental health – lack of high quality interpretable and knowledge grounded training data; training paradigms restricted to core capabilities, and evaluation of multi turn dialogue settings. Addressing it, we present oMind framework which includes training and aligning LLM agents for diverse capabilities including conversations; high quality ~164k multi-task SFT dataset, as a result of our generation pipeline based on Structured Knowledge retrieval, LLM based pruning, and review actions. We also introduce oMind-Chat – a novel multi turn benchmark dataset with expert annotated turn level and conversation level rubrics. Our diverse experiments on both core capabilities and conversations shows oMind LLMs consistently outperform baselines. oMind-LLM also shows significantly better reasoning with up to 80% win rate.

OMIND: Framework for Knowledge Grounded Finetuning and Multi-Turn Dialogue Benchmark for Mental Health LLMs Lire l’article »

AI, Committee, Actualités, Uncategorized

Meta Releases TRIBE v2: A Brain Encoding Model That Predicts fMRI Responses Across Video, Audio, and Text Stimuli

Neuroscience has long been a field of divide and conquer. Researchers typically map specific cognitive functions to isolated brain regions—like motion to area V5 or faces to the fusiform gyrus—using models tailored to narrow experimental paradigms. While this has provided deep insights, the resulting landscape is fragmented, lacking a unified framework to explain how the human brain integrates multisensory information. Meta’s FAIR team has introduced TRIBE v2, a tri-modal foundation model designed to bridge this gap. By aligning the latent representations of state-of-the-art AI architectures with human brain activity, TRIBE v2 predicts high-resolution fMRI responses across diverse naturalistic and experimental conditions. https://ai.meta.com/research/publications/a-foundation-model-of-vision-audition-and-language-for-in-silico-neuroscience/ The Architecture: Multi-modal Integration TRIBE v2 does not learn to ‘see’ or ‘hear’ from scratch. Instead, it leverages the representational alignment between deep neural networks and the primate brain. The architecture consists of three frozen foundation models serving as feature extractors, a temporal transformer, and a subject-specific prediction block. 1. Feature Extraction The model processes stimuli through three specialized encoders: Text: Contextualized embeddings are extracted from LLaMA 3.2-3B. For every word, the model prepends the preceding 1,024 words to provide temporal context, which is then mapped to a 2 Hz grid. Video: The model uses V-JEPA2-Giant to process 64-frame segments spanning the preceding 4 seconds for each time-bin. Audio: Sound is processed through Wav2Vec-BERT 2.0, with representations resampled to 2 Hz to match the stimulus frequency (fstim) (f_{stim}). 2. Temporal Aggregation The resulting embeddings are compressed into a shared dimension (D=384)(D=384) and concatenated to form a multi-modal time series with a model dimension of Dmodel=3×384=1152D_{model} = 3 times 384 = 1152. This sequence is fed into a Transformer encoder (8 layers, 8 attention heads) that exchanges information across a 100-second window. 3. Subject-Specific Prediction To predict brain activity, the Transformer outputs are decimated to the 1 Hz fMRI frequency (ffMRI)(f_{fMRI}) and passed through a Subject Block. This block projects the latent representations to 20,484 cortical vertices (fsaverage5surface)(fsaverage5 surface) and 8,802 subcortical voxels. Data and Scaling Laws A significant hurdle in brain encoding is data scarcity. TRIBE v2 addresses this by utilizing ‘deep’ datasets for training—where a few subjects are recorded for many hours—and ‘wide’ datasets for evaluation. Training: The model was trained on 451.6 hours of fMRI data from 25 subjects across four naturalistic studies (movies, podcasts, and silent videos). Evaluation: It was evaluated across a broader collection totaling 1,117.7 hours from 720 subjects. The research team observed a log-linear increase in encoding accuracy as the training data volume increased, with no evidence of a plateau. This suggests that as neuroimaging repositories expand, the predictive power of models like TRIBE v2 will continue to scale. Results: Beating the Baselines TRIBE v2 significantly outperforms traditional Finite Impulse Response (FIR) models, the long-standing gold standard for voxel-wise encoding. Zero-Shot and Group Performance One of the model’s most striking capabilities is zero-shot generalization to new subjects. Using an ‘unseen subject’ layer, TRIBE v2 can predict the group-averaged response of a new cohort more accurately than the actual recording of many individual subjects within that cohort. In the high-resolution Human Connectome Project (HCP) 7T dataset, TRIBE v2 achieved a group correlation (Rgroup) (R_{group}) near 0.4, a two-fold improvement over the median subject’s group-predictivity. Fine-Tuning When given a small amount of data (at most one hour) for a new participant, fine-tuning TRIBE v2 for just one epoch leads to a two- to four-fold improvement over linear models trained from scratch. In-Silico Experimentation The research team argue that TRIBE v2 could be useful for piloting or pre-screening neuroimaging studies. By running virtual experiments on the Individual Brain Charting (IBC) dataset, the model recovered classic functional landmarks: Vision: It accurately localized the fusiform face area (FFA) and parahippocampal place area (PPA). Language: It successfully recovered the temporo-parietal junction (TPJ) for emotional processing and Broca’s area for syntax. Furthermore, applying Independent Component Analysis (ICA) to the model’s final layer revealed that TRIBE v2 naturally learns five well-known functional networks: primary auditory, language, motion, default mode, and visual. https://aidemos.atmeta.com/tribev2/ Key Takeaway A Powerhouse Tri-modal Architecture: TRIBE v2 is a foundation model that integrates video, audio, and language by leveraging state-of-the-art encoders like LLaMA 3.2 for text, V-JEPA2 for video, and Wav2Vec-BERT for audio. Log-Linear Scaling Laws: Much like the Large Language Models we use every day, TRIBE v2 follows a log-linear scaling law; its ability to accurately predict brain activity increases steadily as it is fed more fMRI data, with no performance plateau currently in sight. Superior Zero-Shot Generalization: The model can predict the brain responses of unseen subjects in new experimental conditions without any additional training. Remarkably, its zero-shot predictions are often more accurate at estimating group-averaged brain responses than the recordings of individual human subjects themselves. The Dawn of In-Silico Neuroscience: TRIBE v2 enables ‘in-silico’ experimentation, allowing researchers to run virtual neuroscientific tests on a computer. It successfully replicated decades of empirical research by identifying specialized areas like the fusiform face area (FFA) and Broca’s area purely through digital simulation. Emergent Biological Interpretability: Even though it’s a deep learning ‘black box,’ the model’s internal representations naturally organized themselves into five well-known functional networks: primary auditory, language, motion, default mode, and visual. Check out the Code, Weights and Demo. Also, feel free to follow us on Twitter and don’t forget to join our 120k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Meta Releases TRIBE v2: A Brain Encoding Model That Predicts fMRI Responses Across Video, Audio, and Text Stimuli appeared first on MarkTechPost.

Meta Releases TRIBE v2: A Brain Encoding Model That Predicts fMRI Responses Across Video, Audio, and Text Stimuli Lire l’article »

AI, Committee, Actualités, Uncategorized

Here’s why some people choose cryonics to store their bodies and brains after death

This week I reported on some rather unusual research that focuses on the brain of L. Stephen Coles. Coles was a gerontologist who died from pancreatic cancer in 2014. He had spent the latter part of his career specializing in human longevity. And before he died, he decided to have his brain preserved by a cryonics facility. Today, it’s being stored at −146 °C at a center in Arizona, where it sits covered in a thin layer of frost. Coles also tasked his longtime friend Greg Fahy with studying pieces of his brain to see how they had fared (partly because he was worried his brain might crack). Fahy, a renowned cryobiologist, has found that the brain is “astonishingly well preserved.” But that doesn’t mean Coles could be reanimated. Over the past few years, I’ve spoken to people who run cryonics facilities, study cryopreservation, or just want to be cryogenically stored. All those I’ve spoken to acknowledge that the chance they’ll one day be brought back to life is vanishingly small. So why do they do it? The first person to be cryonically preserved was James Hiram Bedford, a retired psychology professor who died of kidney cancer in 1967. Affiliates of the Cryonics Society of California, an organization headed by a charming TV repairman with no scientific or medical training, perfused his body with cryoproctective chemicals to protect against harmful ice formation and “quick-froze” him. Today, Bedford’s body is still in storage at Alcor, a cryonics facility based in Scottsdale, Arizona. It’s one of a handful of organizations that offer to collect, preserve, and store a person’s whole body or just their brain—pretty much indefinitely. It’s where Coles’s brain is stored. Both men died from cancer. Medicine could not cure them. But in the future, who knows? One of the premises of cryonics is that modern medicine will continue to advance over time. Cancer death rates have declined significantly in the US since the early 1990s. I don’t know what exactly drove Coles and Bedford to their decisions, but they might have hoped to be reanimated at some point in the future when their cancers became curable. Others simply don’t want to die, period. Last year, I attended Vitalist Bay, a gathering for people who believe that life is good and that death is “humanity’s core problem.” Emil Kendziorra, CEO of the cryonics organization Tomorrow.Bio, spoke at the event, and a healthy interest in cryonics was obvious among the attendees. Many of them believe that science will find a way to “obviate” aging. And some were keen on the idea of being preserved until that happens. Think of it as a way to cheat not only death but aging itself. This sentiment might have support beyond the realms of Vitalist Bay, according to research by Kendziorra and his colleagues. In 2021, they surveyed 1,478 US-based internet users who were recruited via Craigslist. They found that men were more aware of cryonics than women, and more optimistic about its outcomes. Just over a third of the men who completed the survey expressed interest “a desire to live indefinitely.” Still, cryonics is a niche field. Worldwide, only around 5,000 or 6,000 people have signed up for cryopreservation when they die, Kendziorra told me when we chatted at Vitalist Bay. He also told me that his company gets between 20 and 50 new signups every month. And there are plenty of reasons why people don’t do it. A small fraction of the people who responded to Kendziorra’s survey said that they thought the idea of cryonics was dystopian, and some even said it should be illegal. Then there’s the cost. Alcor charges $80,000 to store a person’s brain, and around $220,000 to store a whole body. Tomorrow.Bio’s charges are slightly higher. Many people, including Kendziorra himself, opt to cover this cost via a life insurance policy. Perhaps the main reason people don’t opt for cryonic preservation is that we don’t have any way to bring people back. Bedford has been in storage for more than 50 years, Coles for more than a decade. All the scientists I’ve spoken to say the likelihood of reanimating remains like theirs is vanishingly small. The fact that the possibility—however tiny—is above zero is enough for some, including Nick Llewellyn, the director of research and development at Alcor. As a scientist, he says, he acknowledges that the chances reanimation will actually work are “pretty low.” Still, he’s interested in seeing what the future will look like, so he has signed himself up for the cryonic preservation of his brain. But Shannon Tessier, a cryobiologist at Massachusetts General Hospital, tells me that she wouldn’t sign up for cryonic preservation even if it worked. “It turns into a philosophical question,” she says. “Do I want to be revived hundreds of years later when my family is gone and life is different?” she asks. “There are so many complicated philosophical, societal, [and] legal complications that need to be thought through.” 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.

Here’s why some people choose cryonics to store their bodies and brains after death Lire l’article »

We use cookies to improve your experience and performance on our website. You can learn more at Politique de confidentialité 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
fr_FR