YouZum

Uncategorized

AI, Committee, ニュース, Uncategorized

Inside the stealthy startup that pitched brainless human clones

After operating in secrecy for years, a startup company called R3 Bio, in Richmond, California, suddenly shared details about its work last week—saying it had raised money to create nonsentient monkey “organ sacks” as an alternative to animal testing. In an interview with Wired, R3 listed three investors: billionaire Tim Draper, the Singapore-based fund Immortal Dragons, and life-extension investors LongGame Ventures. But there is more to the story. And R3 doesn’t want that story told. MIT Technology Review discovered that the stealth startup’s founder John Schloendorn also pitched a startling, medically graphic, and ethically charged vision for what he’s called “brainless clones” to serve the role of backup human bodies. Imagine it like this: a baby version of yourself with only enough of a brain structure to be alive in case you ever need a new kidney or liver. Or, alternatively, he has speculated, you might one day get your brain placed into a younger clone. That could be a way to gain a second lifespan through a still hypothetical procedure known as a body transplant. The fuller context of R3’s proposals, as well as activities of another stealth startup with related goals, have not previously been reported. They’ve been kept secret by a circle of extreme life-extension proponents who fear that their plans for immortality could be derailed by clickbait headlines and public backlash. And that’s because the idea can sound like something straight from a creepy science fiction film. One person who heard R3’s clone presentation, and spoke on the condition of anonymity, was left reeling by its implications and shaken by Schloendorn’s enthusiastic delivery. The briefing, this person said, was like a “close encounter of the third kind” with “Dr. Strangelove.” A key inspiration for Schloendorn is a birth defect in which children are born missing most of their cortical hemispheres; he’s shown people medical scans of these kids’ nearly empty skulls as evidence that a body can live without much of a brain.  And he’s talked about how to grow a clone. Since artificial wombs don’t exist yet, brainless bodies can’t be grown in a lab. So he’s said the first batch of brainless clones would have to be carried by women paid to do the job. In the future, though, one brainless clone could give birth to another. Last Monday, the same day it announced itself to the world in Wired, R3 sent us a sweeping disavowal of our findings. It said Schloendorn “never made any statement regarding hypothetical ‘non-sentient human clones’ [that] would be carried by surrogates.” The most overarching of these challenges was its insistence that “any allegations of intent or conspiracy to create human clones or humans with brain damage are categorically false.” But even Schloendorn and his cofounder, Alice Gilman, can’t seem to keep away from the topic. Just last September, the pair presented at Abundance Longevity, a $70,000-per-ticket event in Boston organized by the anti-aging promoter Peter Diamandis. Although the presentation to about 40 people was not recorded and was meant to be confidential, a copy of the agenda for the event shows that Schloendorn was there to outline his “final bid to defeat aging” in a session called “Full Body Replacement.” According to a person who was there, both animal research and personal clones for spare organs were discussed. During the presentation, Gilman and Schloendorn even stood in front of an image of a cloning needle. Pressed on whether this was a talk about brainless clones, Gilman told us that while R3’s current business is replacing animal models, “the team reserves the right to hold hypothetical futuristic discussions.” MIT Technology Review found no evidence that R3 has cloned anyone, or even any animal bigger than a rodent. What we did find were documents, additional meeting agendas, and other sources outlining a technical road map for what R3 called “body replacement cloning” in a 2023 letter to supporters. That road map involved improvements to the cloning process and genetic wiring diagrams for how to create animals without complete brains.  A child with hydranencephaly, a rare condition in which most of the brain is missing. Could a human clone also be created without much of a brain as an ethical source of spare organs?DIMITRI AGAMANOLIS, M.D. VIA WIKIPEDIA A main purpose of the fundraising, investors say, was to support efforts to try these techniques in monkeys from a base in the Caribbean. That offered a path to a nearer-term business plan for more ethical medical experiments and toxicology testing—if the company could develop what it now calls monkey “organ sacks.” However, this work would clearly inform any possible human version.  Though he holds a PhD, Schloendorn is a biotech outsider who has published little and is best known for having once outfitted a DIY lab in his Bay Area garage. Still, his ties to the experimental fringe of longevity science have earned him a network in Silicon Valley and allies at a risk-taking US health innovation agency, ARPA-H. Together with his success at raising money from investors, this signals that the brainless-clone concept should be taken seriously by a wider community of scientists, doctors, and ethicists, some of whom expressed grave concerns.  “It sounds crazy, in my opinion,” said Jose Cibelli, a researcher at Michigan State University, after MIT Technology Review described R3’s brainless-clone idea to him. “How do you demonstrate safety? What is safety when you’re trying to create an abnormal human?” Twenty-five years ago, Cibelli was among the first scientists to try to clone human embryos, but he was trying to obtain matched stem cells, not make a baby. “There is no limit to human imagination and ways to make money, but there have to be boundaries,” he says. “And this is the boundary of making a human being who is not a human being.”  “Feasibility research” Since Dolly the sheep was born in 1996, researchers have cloned dogs, cats, camels, horses, cattle, ferrets, and other species of mammal. Injecting a cell from an existing animal into an

Inside the stealthy startup that pitched brainless human clones 投稿を読む »

AI, Committee, ニュース, Uncategorized

Salesforce AI Research Releases VoiceAgentRAG: A Dual-Agent Memory Router that Cuts Voice RAG Retrieval Latency by 316x

In the world of voice AI, the difference between a helpful assistant and an awkward interaction is measured in milliseconds. While text-based Retrieval-Augmented Generation (RAG) systems can afford a few seconds of ‘thinking’ time, voice agents must respond within a 200ms budget to maintain a natural conversational flow. Standard production vector database queries typically add 50-300ms of network latency, effectively consuming the entire budget before an LLM even begins generating a response. Salesforce AI research team has released VoiceAgentRAG, an open-source dual-agent architecture designed to bypass this retrieval bottleneck by decoupling document fetching from response generation. https://arxiv.org/pdf/2603.02206 The Dual-Agent Architecture: Fast Talker vs. Slow Thinker VoiceAgentRAG operates as a memory router that orchestrates two concurrent agents via an asynchronous event bus: The Fast Talker (Foreground Agent): This agent handles the critical latency path. For every user query, it first checks a local, in-memory Semantic Cache. If the required context is present, the lookup takes approximately 0.35ms. On a cache miss, it falls back to the remote vector database and immediately caches the results for future turns. The Slow Thinker (Background Agent): Running as a background task, this agent continuously monitors the conversation stream. It uses a sliding window of the last six conversation turns to predict 3–5 likely follow-up topics. It then pre-fetches relevant document chunks from the remote vector store into the local cache before the user even speaks their next question. To optimize search accuracy, the Slow Thinker is instructed to generate document-style descriptions rather than questions. This ensures the resulting embeddings align more closely with the actual prose found in the knowledge base. The Technical Backbone: Semantic Caching The system’s efficiency hinges on a specialized semantic cache implemented with an in-memory FAISS IndexFlat IP (inner product). Document-Embedding Indexing: Unlike passive caches that index by query meaning, VoiceAgentRAG indexes entries by their own document embeddings. This allows the cache to perform a proper semantic search over its contents, ensuring relevance even if the user’s phrasing differs from the system’s predictions. Threshold Management: Because query-to-document cosine similarity is systematically lower than query-to-query similarity, the system uses a default threshold of τ=0.40tau = 0.40 to balance precision and recall. Maintenance: The cache detects near-duplicates using a 0.95 cosine similarity threshold and employs a Least Recently Used (LRU) eviction policy with a 300-second Time-To-Live (TTL). Priority Retrieval: On a Fast Talker cache miss, a PriorityRetrieval event triggers the Slow Thinker to perform an immediate retrieval with an expanded top-k (2x the default) to rapidly populate the cache around the new topic area. Benchmarks and Performance The research team evaluated the system using Qdrant Cloud as a remote vector database across 200 queries and 10 conversation scenarios. Metric Performance Overall Cache Hit Rate 75% (79% on warm turns) Retrieval Speedup 316x (110ms→0.35ms)(110ms rightarrow 0.35ms) Total Retrieval Time Saved 16.5 seconds over 200 turns The architecture is most effective in topically coherent or sustained-topic scenarios. For example, ‘Feature comparison’ (S8) achieved a 95% hit rate. Conversely, performance dipped in more volatile scenarios; the lowest-performing scenario was ‘Existing customer upgrade’ (S9) at a 45% hit rate, while ‘Mixed rapid-fire’ (S10) maintained 55%. https://arxiv.org/pdf/2603.02206 Integration and Support The VoiceAgentRAG repository is designed for broad compatibility across the AI stack: LLM Providers: Supports OpenAI, Anthropic, Gemini/Vertex AI, and Ollama. The paper’s default evaluation model was GPT-4o-mini. Embeddings: The research utilized OpenAI text-embedding-3-small (1536 dimensions), but the repository provides support for both OpenAI and Ollama embeddings. STT/TTS: Supports Whisper (local or OpenAI) for speech-to-text and Edge TTS or OpenAI for text-to-speech. Vector Stores: Built-in support for FAISS and Qdrant. Key Takeaways Dual-Agent Architecture: The system solves the RAG latency bottleneck by using a foreground ‘Fast Talker’ for sub-millisecond cache lookups and a background ‘Slow Thinker’ for predictive pre-fetching. Significant Speedup: It achieves a 316x retrieval speedup (110ms→0.35ms)(110ms rightarrow 0.35ms) on cache hits, which is critical for staying within the natural 200ms voice response budget. High Cache Efficiency: Across diverse scenarios, the system maintains a 75% overall cache hit rate, peaking at 95% in topically coherent conversations like feature comparisons. Document-Indexed Caching: To ensure accuracy regardless of user phrasing, the semantic cache indexes entries by document embeddings rather than the predicted query’s embedding. Anticipatory Prefetching: The background agent uses a sliding window of the last 6 conversation turns to predict likely follow-up topics and populate the cache during natural inter-turn pauses. Check out the Paper and Repo here. 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 Salesforce AI Research Releases VoiceAgentRAG: A Dual-Agent Memory Router that Cuts Voice RAG Retrieval Latency by 316x appeared first on MarkTechPost.

Salesforce AI Research Releases VoiceAgentRAG: A Dual-Agent Memory Router that Cuts Voice RAG Retrieval Latency by 316x 投稿を読む »

AI, Committee, ニュース, Uncategorized

The Download: brainless human clones and the first uterus kept alive outside a body

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. Inside the stealthy startup that pitched brainless human clones  After operating in secrecy for years, R3 Bio, a California-based startup, suddenly revealed last week that it had raised money to create nonsentient monkey “organ sacks” as an alternative to animal testing. But there is more to the story. And R3 doesn’t want that story told.  MIT Technology Review discovered that founder John Schloendorn also pitched a startling, ethically charged vision: “brainless clones” that serve as backup human bodies. Find out all the details on the radical proposal.  —Antonio Regalado  A woman’s uterus has been kept alive outside the body for the first time  Ten months ago, reproductive health researchers placed a freshly donated human uterus inside a new device they call “Mother.” They connected the organ to the machine’s plastic veins and arteries and pumped in modified human blood.  The device kept the uterus alive for a day, a new feat that could lead to longer-term maintenance of wombs outside the body. Future versions of the technology could shine new light on pregnancies—and potentially even grow a human fetus. Read the full story.  —Jessica Hamzelou  The must-reads  I’ve combed the internet to find you today’s most fun/important/scary/fascinating stories about technology.  1 AI data centers can significantly warm up surrounding areas  The “heat islands” may already affect 340 million people. (New Scientist) + Mistral has raised $830M to build Nvidia-powered AI centers in Europe. (FT $) + But nobody wants a data center in their backyard. (MIT Technology Review)  2 Elon Musk reportedly joined Trump’s call with Modi about the Iran War It remains unclear what Musk was doing during the conversation. (NYT $)  + India has disputed the report. (Independent) + The war poses a grave threat to the EV market. (Rest of World)  3 Eli Lilly has struck a deal to bring AI-developed drugs to the market It’s secured a $2.75 billion drug collaboration with Insilico Medicine. (Reuters $) + A I-designed compounds can kill drug-resistant bacteria. (MIT Technology Review)  4 More and more countries are curbing children’s social media access Austria is the latest to pursue a ban. (Engadget) + Indonesia has rolled out the first one in Southeast Asia. (DW) + UK Prime Minister Keir Starmer said he will also “have to act.” (Guardian)   5 Tech stocks just had their worst week in nearly a year Thanks to a combination of the Iran war and legal disputes. (CNBC) + Tech insiders are split over the AI bubble. (MIT Technology Review)  6 Meta is launching new smart glasses for prescription wearers It plans to debut them next week. (Bloomberg $)  7 Taiwan is probing 11 Chinese firms for illegal poaching of tech talent Its semiconductors are entangled in the tensions with Beijing. (Reuters)  8 Bluesky has built an AI app for customizing social media feeds It uses Anthropic’s Claude. (TechCrunch)  9 A psychologist is making music with his brain implant He believes enjoyment is a prerequisite for BCI success. (Wired $)  10 The world’s smallest QR code could store data for centuries It’s smaller than bacteria. (Science Daily)  Quote of the day  “We should be thinking about protecting young people in the digital world as opposed to protecting them from the digital world.”  —YouTube CEO Neal Mohan gives the New York Times his take on the debate around children’s safety online.  One More Thing  AJ PICS / ALAMY STOCK PHOTO AI’s growth needs the right interface  You’d have to be pudding-brained to believe that chatbots are the best way to use computers. The real opportunity is a system built atop the visual interfaces we already know, but navigated through a natural mix of voice and touch.  Crucially, this won’t just be a computer that we can use. It’ll be one we can break and remake to suit whatever uses we want. Instead of merely consuming technology like the gelatinous humans in Wall-E, we should be able to architect it to suit our own ends  This idea is already lurching to life. Read the full story to find out how.  —Cliff Kuang  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.)  + These floating designs will elevate your perspective on architecture. + Uğur Gallenkuş’s portraits of two worlds in one image beautifully build bridges. + This is the anti-Karen that the world needs right now. + If only we could all find a love as pure as this kitty clinging to its favorite toy. 

The Download: brainless human clones and the first uterus kept alive outside a body 投稿を読む »

AI, Committee, ニュース, 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 投稿を読む »

AI, Committee, ニュース, 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 投稿を読む »

AI, Committee, ニュース, 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 投稿を読む »

AI, Committee, ニュース, 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 投稿を読む »

AI, Committee, ニュース, 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 投稿を読む »

AI, Committee, ニュース, 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 投稿を読む »

We use cookies to improve your experience and performance on our website. You can learn more at プライバシーポリシー 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
ja