YouZum

Committee

AI, Committee, Nachrichten, Uncategorized

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

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

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

AI, Committee, Nachrichten, Uncategorized

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

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

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

AI, Committee, Nachrichten, Uncategorized

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

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

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

AI, Committee, Nachrichten, Uncategorized

Terminal-Bench 2.0 launches alongside Harbor, a new framework for testing agents in containers

The developers of Terminal-Bench, a benchmark suite for evaluating the performance of autonomous AI agents on real-world terminal-based tasks, have released version 2.0 alongside Harbor, a new framework for testing, improving and optimizing AI agents in containerized environments. The dual release aims to address long-standing pain points in testing and optimizing AI agents, particularly those built to operate autonomously in realistic developer environments. With a more difficult and rigorously verified task set, Terminal-Bench 2.0 replaces version 1.0 as the standard for assessing frontier model capabilities. Harbor, the accompanying runtime framework, enables developers and researchers to scale evaluations across thousands of cloud containers and integrates with both open-source and proprietary agents and training pipelines. “Harbor is the package we wish we had had while making Terminal-Bench,” wrote co-creator Alex Shaw on X. “It’s for agent, model, and benchmark developers and researchers who want to evaluate and improve agents and models.” Higher Bar, Cleaner Data Terminal-Bench 1.0 saw rapid adoption after its release in May 2025, becoming a default benchmark for evaluating agent performance across the field of AI-powered agents operating in developer-style terminal environments. These agents interact with systems through the command line, mimicking how developers work behind the scenes of the graphical user interface. However, its broad scope came with inconsistencies. Several tasks were identified by the community as poorly specified or unstable due to external service changes. Version 2.0 addresses those issues directly. The updated suite includes 89 tasks, each subjected to several hours of manual and LLM-assisted validation. The emphasis is on making tasks solvable, realistic, and clearly specified, raising the difficulty ceiling while improving reliability and reproducibility. A notable example is the download-youtube task, which was removed or refactored in 2.0 due to its dependence on unstable third-party APIs. “Astute Terminal-Bench fans may notice that SOTA performance is comparable to TB1.0 despite our claim that TB2.0 is harder,” Shaw noted on X. “We believe this is because task quality is substantially higher in the new benchmark.” Harbor: Unified Rollouts at Scale Alongside the benchmark update, the team launched Harbor, a new framework for running and evaluating agents in cloud-deployed containers. Harbor supports large-scale rollout infrastructure, with compatibility for major providers like Daytona and Modal. Designed to generalize across agent architectures, Harbor supports: Evaluation of any container-installable agent Scalable supervised fine-tuning (SFT) and reinforcement learning (RL) pipelines Custom benchmark creation and deployment Full integration with Terminal-Bench 2. Harbor was used internally to run tens of thousands of rollouts during the creation of the new benchmark. It is now publicly available via harborframework.com, with documentation for testing and submitting agents to the public leaderboard. Early Results: GPT-5 Leads in Task Success Initial results from the Terminal-Bench 2.0 leaderboard show OpenAI’s Codex CLI (command line interface), a GPT-5 powered variant, in the lead, with a 49.6% success rate — the highest among all agents tested so far. Close behind are other GPT-5 variants and Claude Sonnet 4.5-based agents. Top 5 Agent Results (Terminal-Bench 2.0): Codex CLI (GPT-5) — 49.6% Codex CLI (GPT-5-Codex) — 44.3% OpenHands (GPT-5) — 43.8% Terminus 2 (GPT-5-Codex) — 43.4% Terminus 2 (Claude Sonnet 4.5) — 42.8% The close clustering among top models indicates active competition across platforms, with no single agent solving more than half the tasks. Submission and Use To test or submit an agent, users install Harbor and run the benchmark using simple CLI commands. Submissions to the leaderboard require five benchmark runs, and results can be emailed to the developers along with job directories for validation. harbor run -d terminal-bench@2.0 -m “<model>” -a “<agent>” –n-attempts 5 –jobs-dir <path/to/output> Terminal-Bench 2.0 is already being integrated into research workflows focused on agentic reasoning, code generation, and tool use. According to co-creator Mike Merrill, a postdoctoral researcher at Stanford, a detailed preprint is in progress covering the verification process and design methodology behind the benchmark. Aiming for Standardization The combined release of Terminal-Bench 2.0 and Harbor marks a step toward more consistent and scalable agent evaluation infrastructure. As LLM agents proliferate in developer and operational environments, the need for controlled, reproducible testing has grown. These tools offer a potential foundation for a unified evaluation stack — supporting model improvement, environment simulation, and benchmark standardization across the AI ecosystem.

Terminal-Bench 2.0 launches alongside Harbor, a new framework for testing agents in containers Beitrag lesen »

AI, Committee, Nachrichten, Uncategorized

Google AI Releases ADK Go: A New Open-Source Toolkit Designed to Empower Go Developers to Build Powerful AI Agents

How do you build reliable AI agents that plug into your existing Go services without bolting on a separate language stack? Google has just released Agent Development Kit for Go. Go developers can now build AI agents with the same framework that already supports Python and Java, while keeping everything inside a familiar Go toolchain and deployment model. For AI devs and backend developers who already use Go for services, this closes a gap. You no longer need a separate Python based stack for agents. You can express agent logic, orchestration, and tool use directly in Go code, then move the same agents into Vertex AI Agent Builder and Agent Engine when you are ready for production. What Agent Development Kit Provides? Agent Development Kit, or ADK, is an open source framework for developing and deploying AI agents. It is optimized for Gemini and Google Cloud, but the design is model agnostic and deployment agnostic. In practical terms, ADK gives you: A code first programming model where agent behavior, tools, and orchestration live in normal source files Workflow agents for sequential, parallel, and loop style control flow inside an agent system A rich tool ecosystem with built in tools, custom function tools, OpenAPI tools, Google Cloud tools, and ecosystem tools Deployment paths that cover local runs, containers, Cloud Run, and Vertex AI Agent Engine Built in evaluation and safety patterns, integrated with Vertex AI Agent Builder For a developer, ADK turns an agent into a normal service. You run it locally, inspect traces, and deploy it to a managed runtime, instead of treating it as a one off script that calls an LLM. What ADK for Go Adds? The Go release keeps the same core feature set as the Python and Java SDKs but exposes it through an idiomatic Go API. The Google AI team describes ADK for Go as an idiomatic and performant way to build agents that use Go concurrency and strong typing. Here are some key points: ADK for Go is installed with go get google.golang.org/adk The project is open source and hosted at github.com/google/adk-go It supports building, evaluating, and deploying sophisticated AI agents with flexibility and control It uses the same abstractions for agents, tools, and workflows as the other ADK languages This means a Go service can embed agent behavior without switching languages. You can build a multi agent architecture where each agent is a Go component that composes with others using the same framework. A2A Protocol Support in Go ADK for Go ships with native support for the Agent2Agent protocol, or A2A. The A2A protocol defines a way for agents to call other agents over a standard interface. In the Go release, Google highlights that a primary agent can orchestrate and delegate tasks to specialized sub agents. Those sub agents can run locally or as remote deployments. A2A keeps these interactions secure and opaque, so an agent does not need to expose internal memory or proprietary logic to participate. Google also contributed an A2A Go SDK to the main A2A project. That gives Go developers a protocol level entry point if they want agents that interoperate with other runtimes and frameworks that also support A2A. MCP Toolbox for Databases and Tooling A key detail in the official Google announcement is native integration with MCP Toolbox for Databases. It states that ADK Go has out of the box support for more than 30 databases through this toolbox. MCP Toolbox for Databases is an open source MCP server for databases. It handles connection pooling, authentication, and other concerns, and exposes database operations as tools using the Model Context Protocol. Within ADK, that means: You register MCP Toolbox for Databases as an MCP tool provider The agent calls database operations through MCP tools rather than constructing raw SQL The toolbox enforces a set of safe, predefined actions that the agent can perform This fits the ADK model for tools in general, where agents use a mix of built in tools, Google Cloud tools, ecosystem tools, and MCP tools, all described in the Vertex AI Agent Builder documentation. Integration with Vertex AI Agent Builder and Agent Engine ADK is the primary framework supported in Vertex AI Agent Builder for building multi agent systems. The latest Agent Builder updates describe a build path where you: Develop the agent locally using ADK, now including ADK for Go Use the ADK quickstart and dev UI to test the agent with multiple tools Deploy the agent to Vertex AI Agent Engine as a managed runtime For Go teams, this means the language used in services and infrastructure is now available across the full agent lifecycle, from local development to managed production deployment. Editorial Comments This launch positions Agent Development Kit for Go as a practical bridge between AI agents and existing Go services, using the same open source, code first toolkit that underpins Python and Java agents. It brings A2A protocol support and MCP Toolbox for Databases into a Go native environment, aligned with Vertex AI Agent Builder and Vertex AI Agent Engine for deployment, evaluation, and observability. Overall, this release makes Go a first class language for building production ready, interoperable AI agents in Google’s ecosystem. Check out the Repo, Samples and Technical details. Feel free to check out our GitHub Page for Tutorials, Codes and Notebooks. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Google AI Releases ADK Go: A New Open-Source Toolkit Designed to Empower Go Developers to Build Powerful AI Agents appeared first on MarkTechPost.

Google AI Releases ADK Go: A New Open-Source Toolkit Designed to Empower Go Developers to Build Powerful AI Agents Beitrag lesen »

AI, Committee, Nachrichten, Uncategorized

Why Spatial Supersensing is Emerging as the Core Capability for Multimodal AI Systems?

Even strong ‘long-context’ AI models fail badly when they must track objects and counts over long, messy video streams, so the next competitive edge will come from models that predict what comes next and selectively remember only surprising, important events, not from just buying more compute and bigger context windows. A team of researchers from New York University and Stanford introduce Cambrian-S, a spatially grounded video multimodal large language model family, together with the VSI Super benchmark and the VSI 590K dataset to test and train spatial supersensing in long videos. https://arxiv.org/pdf/2511.04670 From video question answering to spatial supersensing The research team frames spatial supersensing as a progression of capabilities beyond linguistic only reasoning. The stages are semantic perception, streaming event cognition, implicit 3D spatial cognition and predictive world modeling. Most current video MLLMs sample sparse frames and rely on language priors. They often answer benchmark questions using captions or single frames rather than continuous visual evidence. Diagnostic tests show that several popular video benchmarks are solvable with limited or text only input, so they do not strongly test spatial sensing. Cambrian-S targets the higher stages of this hierarchy, where the model must remember spatial layouts across time, reason about object locations and counts and anticipate changes in a 3D world. VSI Super, a stress test for continual spatial sensing To expose the gap between current systems and spatial supersensing, the research team designed VSI Super, a two part benchmark that runs on arbitrarily long indoor videos. https://arxiv.org/pdf/2511.04670 VSI Super Recall, or VSR, evaluates long horizon spatial observation and recall. Human annotators take indoor walkthrough videos from ScanNet, ScanNet++ and ARKitScenes and use Gemini to insert an unusual object, such as a Teddy Bear, into four frames at different spatial locations. These edited sequences are concatenated into streams up to 240 minutes. The model must report the order of locations where the object appears, which is a visual needle in a haystack task with sequential recall. https://arxiv.org/pdf/2511.04670 VSI Super Count, or VSC, measures continual counting under changing viewpoints and rooms. The benchmark concatenates room tour clips from VSI Bench and asks for the total number of instances of a target object across all rooms. The model must handle viewpoint changes, revisits and scene transitions and maintain a cumulative count. Evaluation uses mean relative accuracy for durations from 10 to 120 minutes. When Cambrian-S 7B is evaluated on VSI Super in a streaming setup at 1 frame per second, accuracy on VSR drops from 38.3 percent at 10 minutes to 6.0 percent at 60 minutes and becomes zero beyond 60 minutes. VSC accuracy is near zero across lengths. Gemini 2.5 Flash also degrades on VSI Super despite a long context window, which shows that brute force context scaling is not sufficient for continual spatial sensing. VSI 590K, spatially focused instruction data To test whether data scaling can help, the research team construct VSI 590K, a spatial instruction corpus with 5,963 videos, 44,858 images and 590,667 question answer pairs from 10 sources. Sources include 3D annotated real indoor scans such as ScanNet, ScanNet++ V2, ARKitScenes, S3DIS and Aria Digital Twin, simulated scenes from ProcTHOR and Hypersim and pseudo annotated web data such as YouTube RoomTour and robot datasets Open X Embodiment and AgiBot World. The dataset defines 12 spatial question types, such as object count, absolute and relative distance, object size, room size and appearance order. Questions are generated from 3D annotations or reconstructions so that spatial relationships are grounded in geometry rather than text heuristics. Ablations show that annotated real videos contribute the largest gains on VSI Bench, followed by simulated data and then pseudo annotated images and that training on the full mix gives the best spatial performance. https://arxiv.org/pdf/2511.04670 Cambrian-S model family and spatial performance Cambrian-S builds on Cambrian-1 and uses Qwen2.5 language backbones at 0.5B, 1.5B, 3B and 7B parameters with a SigLIP2 SO400M vision encoder and a two layer MLP connector. Training follows a four stage pipeline. Stage 1 performs vision language alignment on image text pairs. Stage 2 applies image instruction tuning, equivalent to the improved Cambrian-1 setup. Stage 3 extends to video with general video instruction tuning on a 3 million sample mixture called Cambrian-S 3M. Stage 4 performs spatial video instruction tuning on a mixture of VSI 590K and a subset of the stage 3 data. https://arxiv.org/pdf/2511.04670 On VSI Bench, Cambrian-S 7B reaches 67.5 percent accuracy and outperforms open source baselines like InternVL3.5 8B and Qwen VL 2.5 7B as well as proprietary Gemini 2.5 Pro by more than 16 absolute points. The model also maintains strong performance on Perception Test, EgoSchema and other general video benchmarks, so the focus on spatial sensing does not destroy general capabilities. Predictive sensing with latent frame prediction and surprise To go beyond static context expansion, the research team propose predictive sensing. They add a Latent Frame Prediction head, which is a two layer MLP that predicts the latent representation of the next video frame in parallel with next token prediction. Training modifies stage 4. The model uses mean squared error and cosine distance losses between predicted and ground truth latent features, weighted against the language modeling loss. A subset of 290,000 videos from VSI 590K, sampled at 1 frame per second, is reserved for this objective. During this stage the connector, language model and both output heads are trained jointly, while the SigLIP vision encoder remains frozen. https://arxiv.org/pdf/2511.04670 At inference time the cosine distance between predicted and actual features becomes a surprise score. Frames with low surprise are compressed before being stored in long term memory and high surprise frames are retained with more detail. A fixed size memory buffer uses surprise to decide which frames to consolidate or drop and queries retrieve frames that are most relevant to the question. https://arxiv.org/pdf/2511.04670 For VSR, this surprise driven memory system lets Cambrian-S maintain accuracy as video length increases while keeping GPU memory usage stable. It outperforms Gemini 1.5 Flash and Gemini 2.5 Flash on VSR at all tested

Why Spatial Supersensing is Emerging as the Core Capability for Multimodal AI Systems? Beitrag lesen »

AI, Committee, Nachrichten, Uncategorized

Pragmatic Reasoning improves LLM Code Generation

arXiv:2502.15835v3 Announce Type: replace Abstract: Large Language Models (LLMs) have demonstrated impressive potential in translating natural language (NL) instructions into program code. However, user instructions often contain inherent ambiguities, making it challenging for LLMs to generate code that accurately reflects the user’s true intent. To address this challenge, researchers have proposed approaches that produce multiple candidates of the program code and then rerank them to identify the best solution. In this paper, we propose CodeRSA, a novel code candidate reranking mechanism built upon the Rational Speech Act (RSA) framework, designed to guide LLMs toward more comprehensive pragmatic reasoning about user intent. We evaluate CodeRSA using Llama-3-8B-Instruct and Qwen-2.5-7B-Instruct on two widely used code generation benchmarks, HumanEval and MBPP. Our experiment results show that CodeRSA consistently outperforms common baselines, surpasses the state-of-the-art approach in most cases, and demonstrates robust overall performance. These findings underscore the effectiveness of integrating pragmatic reasoning into code candidate reranking, offering a promising direction for enhancing code generation quality in LLMs.

Pragmatic Reasoning improves LLM Code Generation Beitrag lesen »

AI, Committee, Nachrichten, Uncategorized

IntelliProof: An Argumentation Network-based Conversational Helper for Organized Reflection

arXiv:2511.04528v1 Announce Type: new Abstract: We present IntelliProof, an interactive system for analyzing argumentative essays through LLMs. IntelliProof structures an essay as an argumentation graph, where claims are represented as nodes, supporting evidence is attached as node properties, and edges encode supporting or attacking relations. Unlike existing automated essay scoring systems, IntelliProof emphasizes the user experience: each relation is initially classified and scored by an LLM, then visualized for enhanced understanding. The system provides justifications for classifications and produces quantitative measures for essay coherence. It enables rapid exploration of argumentative quality while retaining human oversight. In addition, IntelliProof provides a set of tools for a better understanding of an argumentative essay and its corresponding graph in natural language, bridging the gap between the structural semantics of argumentative essays and the user’s understanding of a given text. A live demo and the system are available here to try: textbf{https://intelliproof.vercel.app}

IntelliProof: An Argumentation Network-based Conversational Helper for Organized Reflection Beitrag lesen »

We use cookies to improve your experience and performance on our website. You can learn more at Datenschutzrichtlinie 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
de_DE