Scientific research across fields like chemistry, biology, and artificial intelligence has long relied on human experts to explore knowledge, generate ideas, design experiments, and refine results. Yet, as problems grow more complex and data-intensive, discovery slows. While AI tools, such as language models and robotics, can handle specific tasks, like literature searches or code analysis, they rarely encompass the entire research cycle. Bridging the gap between idea generation and experimental validation remains a key challenge. For AI to autonomously advance science, it must propose hypotheses, design and execute experiments, analyze outcomes, and refine approaches in an iterative loop. Without this integration, AI risks producing disconnected ideas that depend on human supervision for validation. Before the introduction of a unified system, researchers relied on separate tools for each stage of the process. Large language models could help find relevant scientific papers, but they didn’t directly feed into experiment design or result analysis. Robotics can assist in automating physical experiments, and coding libraries like PyTorch can help build models; however, these tools operate independently of each other. There was no single system capable of handling the entire process, from forming ideas to verifying them through experiments. This led to bottlenecks, where researchers had to connect the dots manually, slowing progress and leaving room for errors or missed opportunities. The need for an integrated system that could handle the entire research cycle became clear. Researchers from the NovelSeek Team at the Shanghai Artificial Intelligence Laboratory developed NovelSeek, an AI system designed to run the entire scientific discovery process autonomously. NovelSeek comprises four main modules that work in tandem: a system that generates and refines research ideas, a feedback loop where human experts can interact with and refine these ideas, a method for translating ideas into code and experiment plans, and a process for conducting multiple rounds of experiments. What makes NovelSeek stand out is its versatility; it works across 12 scientific research tasks, including predicting chemical reaction yields, understanding molecular dynamics, forecasting time-series data, and handling functions like 2D semantic segmentation and 3D object classification. The team designed NovelSeek to minimize human involvement, expedite discoveries, and deliver consistent, high-quality results. The system behind NovelSeek involves multiple specialized agents, each focused on a specific part of the research workflow. The “Survey Agent” helps the system understand the problem by searching scientific papers and identifying relevant information based on keywords and task definitions. It adapts its search strategy by first doing a broad survey of papers, then going deeper by analyzing full-text documents for detailed insights. This ensures that the system captures both general trends and specific technical knowledge. The “Code Review Agent” examines existing codebases, whether user-uploaded or sourced from public repositories like GitHub, to understand how current methods work and identify areas for improvement. It checks how code is structured, looks for errors, and creates summaries that help the system build on past work. The “Idea Innovation Agent” generates creative research ideas, pushing the system to explore different approaches and refine them by comparing them to related studies and previous results. The system even includes a “Planning and Execution Agent” that turns ideas into detailed experiments, handles errors during the testing process, and ensures smooth execution of multi-step research plans. NovelSeek delivered impressive results across various tasks. In chemical reaction yield prediction, NovelSeek improved performance from a baseline of 24.2% (with a variation of ±4.2) to 34.8% (with a much smaller variation of ±1.1) in just 12 hours, progress that human researchers typically need months to achieve. In enhancer activity prediction, a key task in biology, NovelSeek raised the Pearson correlation coefficient from 0.65 to 0.79 within 4 hours. For 2D semantic segmentation, a task used in computer vision, precision improved from 78.8% to 81.0% in just 30 hours. These performance boosts, achieved in a fraction of the time typically needed, highlight the system’s efficiency. NovelSeek also successfully managed large, complex codebases with multiple files, demonstrating its ability to handle research tasks at a project level, not just in small, isolated tests. The team has made the code open-source, allowing others to use, test, and contribute to its improvement. Several Key Takeaways from the Research on NovelSeek include: NovelSeek supports 12 research tasks, including chemical reaction prediction, molecular dynamics, and 3D object classification. Reaction yield prediction accuracy improved from 24.2% to 34.8% in 12 hours. Enhancer activity prediction performance increased from 0.65 to 0.79 in 4 hours. 2D semantic segmentation precision improved from 78.8% to 81.0% in 30 hours. NovelSeek includes agents for literature search, code analysis, idea generation, and experiment execution. The system is open-source, enabling reproducibility and collaboration across scientific fields. In conclusion, NovelSeek demonstrates how combining AI tools into a single system can accelerate scientific discovery and reduce its dependence on human effort. It ties together the key steps, generating ideas, turning them into methods, and testing them through experiments, into one streamlined process. What once took researchers months or years can now be done in days or even hours. By linking every stage of research into a continuous loop, NovelSeek helps teams move from rough ideas to real-world results more quickly. This system highlights the power of AI not just to assist, but to drive scientific research in a way that could reshape how discoveries are made across many fields. Check out the Paper and GitHub Page . All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 95k+ ML SubReddit and Subscribe to our Newsletter. NikhilNikhil is an intern consultant at Marktechpost. He is pursuing an integrated dual degree in Materials at the Indian Institute of Technology, Kharagpur. Nikhil is an AI/ML enthusiast who is always researching applications in fields like biomaterials and biomedical science. With a strong background in Material Science, he is exploring new advancements and creating opportunities to contribute.Nikhilhttps://www.marktechpost.com/author/nikhil0980/This AI Paper Introduces ARM and Ada-GRPO: Adaptive Reasoning Models for Efficient and Scalable Problem-SolvingNikhilhttps://www.marktechpost.com/author/nikhil0980/This AI Paper Introduces WEB-SHEPHERD: A Process Reward Model for Web Agents with 40K Dataset and 10× Cost EfficiencyNikhilhttps://www.marktechpost.com/author/nikhil0980/This AI Paper Introduces MMaDA: A Unified Multimodal Diffusion Model for Textual Reasoning, Visual Understanding, and Image GenerationNikhilhttps://www.marktechpost.com/author/nikhil0980/This AI Paper Introduces Differentiable MCMC Layers: A New AI Framework for Learning with Inexact Combinatorial Solvers in Neural Networks

In this tutorial, we implement the Agent Communication Protocol (ACP) through building a flexible, ACP-compliant messaging system in Python, leveraging Google’s Gemini API for natural language processing. Beginning with the installation and configuration of the google-generativeai library, the tutorial introduces core abstractions, message types, performatives, and the ACPMessage data class, which standardizes inter-agent communication. By defining ACPAgent and ACPMessageBroker classes, the guide demonstrates how to create, send, route, and process structured messages among multiple autonomous agents. Through clear code examples, users learn to implement querying, requesting actions, and broadcasting information, while maintaining conversation threads, acknowledgments, and error handling. import google.generativeai as genai import json import time import uuid from enum import Enum from typing import Dict, List, Any, Optional from dataclasses import dataclass, asdict GEMINI_API_KEY = "Use Your Gemini API Key" genai.configure(api_key=GEMINI_API_KEY) We import essential Python modules, ranging from JSON handling and timing to unique identifier generation and type annotations, to support a structured ACP implementation. It then retrieves the user’s Gemini API key placeholder and configures the google-generativeai client for subsequent calls to the Gemini language model. class ACPMessageType(Enum): """Standard ACP message types""" REQUEST = "request" RESPONSE = "response" INFORM = "inform" QUERY = "query" SUBSCRIBE = "subscribe" UNSUBSCRIBE = "unsubscribe" ERROR = "error" ACK = "acknowledge" The ACPMessageType enumeration defines the core message categories used in the Agent Communication Protocol, including requests, responses, informational broadcasts, queries, and control actions like subscription management, error signaling, and acknowledgments. By centralizing these message types, the protocol ensures consistent handling and routing of inter-agent communications throughout the system. class ACPPerformative(Enum): """ACP speech acts (performatives)""" TELL = "tell" ASK = "ask" REPLY = "reply" REQUEST_ACTION = "request-action" AGREE = "agree" REFUSE = "refuse" PROPOSE = "propose" ACCEPT = "accept" REJECT = "reject" The ACPPerformative enumeration captures the variety of speech acts agents can use when interacting under the ACP framework, mapping high-level intentions, such as making requests, posing questions, giving commands, or negotiating agreements, onto standardized labels. This clear taxonomy enables agents to interpret and respond to messages in contextually appropriate ways, ensuring robust and semantically rich communication. @dataclass class ACPMessage: """Agent Communication Protocol Message Structure""" message_id: str sender: str receiver: str performative: str content: Dict[str, Any] protocol: str = "ACP-1.0" conversation_id: str = None reply_to: str = None language: str = "english" encoding: str = "json" timestamp: float = None def __post_init__(self): if self.timestamp is None: self.timestamp = time.time() if self.conversation_id is None: self.conversation_id = str(uuid.uuid4()) def to_acp_format(self) -> str: """Convert to standard ACP message format""" acp_msg = { "message-id": self.message_id, "sender": self.sender, "receiver": self.receiver, "performative": self.performative, "content": self.content, "protocol": self.protocol, "conversation-id": self.conversation_id, "reply-to": self.reply_to, "language": self.language, "encoding": self.encoding, "timestamp": self.timestamp } return json.dumps(acp_msg, indent=2) @classmethod def from_acp_format(cls, acp_string: str) -> 'ACPMessage': """Parse ACP message from string format""" data = json.loads(acp_string) return cls( message_id=data["message-id"], sender=data["sender"], receiver=data["receiver"], performative=data["performative"], content=data["content"], protocol=data.get("protocol", "ACP-1.0"), conversation_id=data.get("conversation-id"), reply_to=data.get("reply-to"), language=data.get("language", "english"), encoding=data.get("encoding", "json"), timestamp=data.get("timestamp", time.time()) ) The ACPMessage data class encapsulates all the fields required for a structured ACP exchange, including identifiers, participants, performative, payload, and metadata such as protocol version, language, and timestamps. Its __post_init__ method auto-populates missing timestamp and conversation_id values, ensuring every message is uniquely tracked. Utility methods to_acp_format and from_acp_format handle serialization to and from the standardized JSON representation for seamless transmission and parsing. class ACPAgent: """Agent implementing Agent Communication Protocol""" def __init__(self, agent_id: str, name: str, capabilities: List[str]): self.agent_id = agent_id self.name = name self.capabilities = capabilities self.model = genai.GenerativeModel("gemini-1.5-flash") self.message_queue: List[ACPMessage] = [] self.subscriptions: Dict[str, List[str]] = {} self.conversations: Dict[str, List[ACPMessage]] = {} def create_message(self, receiver: str, performative: str, content: Dict[str, Any], conversation_id: str = None, reply_to: str = None) -> ACPMessage: """Create a new ACP-compliant message""" return ACPMessage( message_id=str(uuid.uuid4()), sender=self.agent_id, receiver=receiver, performative=performative, content=content, conversation_id=conversation_id, reply_to=reply_to ) def send_inform(self, receiver: str, fact: str, data: Any = None) -> ACPMessage: """Send an INFORM message (telling someone a fact)""" content = {"fact": fact, "data": data} return self.create_message(receiver, ACPPerformative.TELL.value, content) def send_query(self, receiver: str, question: str, query_type: str = "yes-no") -> ACPMessage: """Send a QUERY message (asking for information)""" content = {"question": question, "query-type": query_type} return self.create_message(receiver, ACPPerformative.ASK.value, content) def send_request(self, receiver: str, action: str, parameters: Dict = None) -> ACPMessage: """Send a REQUEST message (asking someone to perform an action)""" content = {"action": action, "parameters": parameters or {}} return self.create_message(receiver, ACPPerformative.REQUEST_ACTION.value, content) def send_reply(self, original_msg: ACPMessage, response_data: Any) -> ACPMessage: """Send a REPLY message in response to another message""" content = {"response": response_data, "original-question": original_msg.content} return self.create_message( original_msg.sender, ACPPerformative.REPLY.value, content, conversation_id=original_msg.conversation_id, reply_to=original_msg.message_id ) def process_message(self, message: ACPMessage) -> Optional[ACPMessage]: """Process incoming ACP message and generate appropriate response""" self.message_queue.append(message) conv_id = message.conversation_id if conv_id not in self.conversations: self.conversations[conv_id] = [] self.conversations[conv_id].append(message) if message.performative == ACPPerformative.ASK.value: return self._handle_query(message) elif message.performative == ACPPerformative.REQUEST_ACTION.value: return self._handle_request(message) elif message.performative == ACPPerformative.TELL.value: return self._handle_inform(message) return None def _handle_query(self, message: ACPMessage) -> ACPMessage: """Handle incoming query messages""" question = message.content.get("question", "") prompt = f"As agent {self.name} with capabilities {self.capabilities}, answer: {question}" try: response = self.model.generate_content(prompt) answer = response.text.strip() except: answer = "Unable to process query at this time" return self.send_reply(message, {"answer": answer, "confidence": 0.8}) def _handle_request(self, message: ACPMessage) -> ACPMessage: """Handle incoming action requests""" action = message.content.get("action", "") parameters = message.content.get("parameters", {}) if any(capability in action.lower() for capability in self.capabilities): result = f"Executing {action} with parameters {parameters}" status = "agreed" else: result = f"Cannot perform {action} - not in my capabilities" status = "refused" return self.send_reply(message, {"status": status, "result": result}) def _handle_inform(self, message: ACPMessage) -> Optional[ACPMessage]: """Handle incoming information messages""" fact = message.content.get("fact", "") print(f"[{self.name}] Received information: {fact}") ack_content = {"status": "received", "fact": fact} return self.create_message(message.sender, "acknowledge", ack_content, conversation_id=message.conversation_id) The ACPAgent class encapsulates an autonomous entity capable of sending, receiving, and processing ACP-compliant messages using Gemini’s language model. It manages its own message queue, conversation history, and subscriptions, and provides helper methods (send_inform, send_query, send_request, send_reply) to construct correctly formatted ACPMessage instances. Incoming messages are routed through process_message, which delegates to specialized handlers for queries, action requests, and informational messages. class ACPMessageBroker: """Message broker implementing ACP routing and delivery""" def __init__(self): self.agents: Dict[str, ACPAgent] = {} self.message_log: List[ACPMessage] = [] self.routing_table: Dict[str, str] = {} def register_agent(self, agent: ACPAgent): """Register an agent with the message broker""" self.agents[agent.agent_id] = agent self.routing_table[agent.agent_id] = "local" print(f"✓ Registered agent: {agent.name} ({agent.agent_id})") def route_message(self, message: ACPMessage) -> bool: """Route ACP message to appropriate recipient""" if message.receiver not in self.agents: print(f"✗ Receiver {message.receiver} not found") return False print(f"\n📨 ACP MESSAGE ROUTING:") print(f"From: {message.sender} → To: {message.receiver}") print(f"Performative: {message.performative}") print(f"Content: {json.dumps(message.content, indent=2)}") receiver_agent = self.agents[message.receiver] response = receiver_agent.process_message(message) self.message_log.append(message) if response: print(f"\n📤 GENERATED RESPONSE:") print(f"From: {response.sender} → To: {response.receiver}") print(f"Content: {json.dumps(response.content, indent=2)}") if response.receiver in self.agents: self.agents[response.receiver].process_message(response) self.message_log.append(response) return True def broadcast_message(self, message: ACPMessage, recipients: List[str]): """Broadcast message to multiple recipients""" for recipient in recipients: msg_copy = ACPMessage( message_id=str(uuid.uuid4()), sender=message.sender, receiver=recipient, performative=message.performative, content=message.content.copy(), conversation_id=message.conversation_id ) self.route_message(msg_copy) The ACPMessageBroker serves as the central router for ACP messages, maintaining a registry of agents and a message log. It provides methods to register agents, deliver individual messages via route_message, which handles lookup, logging, and response chaining, and to send the same message to multiple recipients with broadcast_message. def demonstrate_acp(): """Comprehensive demonstration of Agent Communication Protocol""" print("🤖 AGENT COMMUNICATION PROTOCOL (ACP) DEMONSTRATION") print("=" * 60) broker = ACPMessageBroker() researcher = ACPAgent("agent-001", "Dr. Research", ["analysis", "research", "data-processing"]) assistant = ACPAgent("agent-002", "AI Assistant", ["information", "scheduling", "communication"]) calculator = ACPAgent("agent-003", "MathBot", ["calculation", "mathematics", "computation"]) broker.register_agent(researcher) broker.register_agent(assistant) broker.register_agent(calculator) print(f"\n📋 REGISTERED AGENTS:") for agent_id, agent in broker.agents.items(): print(f" • {agent.name} ({agent_id}): {', '.join(agent.capabilities)}") print(f"\n🔬 SCENARIO 1: Information Query (ASK performative)") query_msg = assistant.send_query("agent-001", "What are the key factors in AI research?") broker.route_message(query_msg) print(f"\n🔢 SCENARIO 2: Action Request (REQUEST-ACTION performative)") calc_request = researcher.send_request("agent-003", "calculate", {"expression": "sqrt(144) + 10"}) broker.route_message(calc_request) print(f"\n📢 SCENARIO 3: Information Sharing (TELL performative)") info_msg = researcher.send_inform("agent-002", "New research paper published on quantum computing") broker.route_message(info_msg) print(f"\n📊 PROTOCOL STATISTICS:") print(f" • Total messages processed: {len(broker.message_log)}") print(f" • Active conversations: {len(set(msg.conversation_id for msg in broker.message_log))}") print(f" • Message types used: {len(set(msg.performative for msg in broker.message_log))}") print(f"\n📋 SAMPLE ACP MESSAGE FORMAT:") sample_msg = assistant.send_query("agent-001", "Sample question for format demonstration") print(sample_msg.to_acp_format()) The demonstrate_acp function orchestrates a hands-on walkthrough of the entire ACP framework: it initializes a broker and three distinct agents (Researcher, AI Assistant, and MathBot), registers them, and illustrates three key interaction scenarios, querying for information, requesting a computation, and sharing an update. After routing each message and handling responses, it prints summary statistics on the message flow. It showcases a formatted ACP message, providing users with a clear, end-to-end example of how agents communicate under the protocol. def setup_guide(): print(""" 🚀 GOOGLE COLAB SETUP GUIDE: 1. Get Gemini API Key: https://makersuite.google.com/app/apikey 2. Replace: GEMINI_API_KEY = "YOUR_ACTUAL_API_KEY" 3. Run: demonstrate_acp() 🔧 ACP PROTOCOL FEATURES: • Standardized message format with required fields • Speech act performatives (TELL, ASK, REQUEST-ACTION, etc.) • Conversation tracking and message threading • Error handling and acknowledgments • Message routing and delivery confirmation 📝 EXTEND THE PROTOCOL: ```python # Create custom agent my_agent = ACPAgent("my-001", "CustomBot", ["custom-capability"]) broker.register_agent(my_agent) # Send custom message msg = my_agent.send_query("agent-001", "Your question here") broker.route_message(msg) ``` """) if __name__ == "__main__": setup_guide() demonstrate_acp() Finally, the setup_guide function provides a quick-start reference for running the ACP demo in Google Colab, outlining how to obtain and configure your Gemini API key and invoke the demonstrate_acp routine. It also summarizes key protocol features, such as standardized message formats, performatives, and message routing. It provides a concise code snippet illustrating how to register custom agents and send tailored messages. In conclusion, this tutorial implements ACP-based multi-agent systems capable of research, computation, and collaboration tasks. The provided sample scenarios illustrate common use cases, information queries, computational requests, and fact sharing, while the broker ensures reliable message delivery and logging. Readers are encouraged to extend the framework by adding new agent capabilities, integrating domain-specific actions, or incorporating more sophisticated subscription and notification mechanisms. Download the Notebook on GitHub. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 95k+ ML SubReddit and Subscribe to our Newsletter. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/Yandex Releases Yambda: The World’s Largest Event Dataset to Accelerate Recommender SystemsAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Stanford Researchers Introduced Biomni: A Biomedical AI Agent for Automation Across Diverse Tasks and Data TypesAsif Razzaqhttps://www.marktechpost.com/author/6flvq/DeepSeek Releases R1-0528: An Open-Source Reasoning AI Model Delivering Enhanced Math and Code Performance with Single-GPU EfficiencyAsif Razzaqhttps://www.marktechpost.com/author/6flvq/A Coding Guide for Building a Self-Improving AI Agent Using Google’s Gemini API with Intelligent Adaptation Features

Designing human-centered AI products can be arduous.Keeping up with the overall pace of change isn’t easy. But here’s a bigger challenge:The wildly different paces of change attached to the key elements of AI product strategy, design, and development can make managing those elements — and even thinking about them — overwhelming.Yesterday’s design processes and frameworks offer priceless guidance that still holds. But in many spots, they just don’t fit today’s environment.For instance, designers used to map out and user-test precise, predictable end-to-end screen flows. But flows are no longer precisely predictable. AI generates dynamic dialogues and custom-tailored flows on the fly, rendering much of the old practice unhelpful and infeasible.It’s easy for product teams to feel adrift nowadays — we can hoist the sails, but we’re missing a map and a rudder. We need frameworks tailored to the traits that fundamentally set AI apart from traditional software, including:its capabilities for autonomy and collaboration,its probabilistic nature,its early need for quality data, andits predictable unpredictability. Humans tend to be perpetually surprised by its abilities — and its inabilities.AI pace layers: design for resilienceHere’s a framework to address these challenges.Building on Stewart Brand’s “Shearing Layers” framework, AI Pace Layers helps teams grow thriving AI products by framing them as layered systems with components that function and evolve at different timescales.It helps anticipate points of friction and create resilient and humane products.Each layer represents a specific domain of activity and responsibility, with a distinct pace of change.* Unlike the other layers, Services cuts across multiple layers rather than sitting between them, and its pace of change fluctuates erratically.Boundaries between layers call for special attention and care — friction at these points can produce destructive shearing and constructive turbulence.I’ll dive deeper into this framework with some practical examples showing how it works. But first, a brief review of the precursors that inspired this framework will help you put it to good use.The foundationsThis model builds on the insights of several influential design frameworks from the professions of building architecture and traditional software design.Shearing layers (Duffy and Brand)In his 1994 book How Buildings Learn, Stewart Brand expanded on architect Frank Duffy’s concept of shearing layers. The core insight: buildings consist of components that change at different rates.Shell, Services, Scenery, and Sets. (Frank Duffy, 1992).“…there isn’t any such thing as a building. A building properly conceived is several layers of longevity of built components.” — Frank DuffyShearing Layers of Change, from How Buildings Learn: What Happens after they’re built (Stewart Brand, 1994).Expanding on Duffy’s work, Brand identified six layers, from the slow-changing “Site” to the rapidly evolving “Stuff.”As the layers move at different speeds, friction forms where they meet. Buildings designed without mindful consideration of these different velocities tear themselves apart at these “shearing” points. Before long, they tend to be demolished and replaced.Buildings designed for resiliency allow for “slippage” between the moving layers — flexibility for the different rates of change to unfold with minimal conflict. Such buildings can thrive and remain useful for hundreds of years.Pace layers (Brand)In 1999, Brand drew insights from ecologists to expand this concept beyond buildings and encompass human society. In The Clock Of The Long Now: Time And Responsibility, he proposed “Pace Layers” — six levels ranging from rapid fashion to glacially-slow nature.Brand’s Pace Layers (1999) as sketched by Jono Hey.Brand again pointed out the boundaries, where the most intriguing and consequential changes emerge. Friction at the tension points can tear a building apart — or spur a civilization’s collapse–when we try to bind the layers too tightly together. But with mindful design and planning for slippage, activity along these boundary zones can also generate “constructive turbulence” that keeps systems balanced and resilient.The most successful systems survive and thrive through times of change through resiliency, by absorbing and incorporating shocks.“…a few scientists (such as R. V. O’Neill and C. S. Holling) have been probing the same issue in ecological systems: how do they manage change, how do they absorb and incorporate shocks? The answer appears to lie in the relationship between components in a system that have different change-rates and different scales of size. Instead of breaking under stress like something brittle, these systems yield as if they were soft. Some parts respond quickly to the shock, allowing slower parts to ignore the shock and maintain their steady duties of system continuity.” — Stewart BrandRoles and tendencies of the fast (upper) and slow (lower) layers. (Brand).Slower layers provide constraints and underpinnings for the faster layers, while faster layers induce adaptations in the slower layers that evolve the system.Elements of UX (Garrett)Jesse James Garrett’s classic The Elements of User Experience (2002) presents a five-layer model for digital design:Surface (visual design)Skeleton (interface design, navigation design, information design)Structure (interaction design, information architecture)Scope (functional specs, content requirements)Strategy (user needs, site objectives)Structure, Scope, and Strategy. Each layer answers a different set of questions, with the questions answered at each level setting constraints for the levels above. Lower layers set boundaries and underpinnings that help define the more concrete layers.Jesse James Garrett’s 5 layers from The Elements of User Experience Design (2002)This framework doesn’t focus on time, or on tension points resulting from conflicting velocities. But it provides a comprehensive structure for shaping different aspects of digital product design, from abstract strategy to concrete surface elements.AI Pace Layers: diving deeperBuilding on these foundations, the AI Pace Layers framework adapts these concepts specifically for AI systems design.Let’s explore each layer and understand how design expertise contributes across the framework.SessionsPace of change: Very fast (milliseconds to minutes)Focus: Performance of real-time interactions.This layer encompasses real-time dialogue, reasoning, and processing. These interplays happen between the user and AI, and between AI agents and other services and people, on behalf of the user. Sessions draw on lower-layer capabilities and components to deliver the “moments of truth” where product experiences succeed or fail. Feedback from the Sessions layer is crucial for improving and evolving the lower layers.Key contributors: Users and AI agents — usually with zero direct human involvement backstage.Example actions/decisions/artifacts: User/AI dialogue. Audio, video, text, images, and widgets are rendered on the fly (using building blocks provided by lower levels). Real-time adaptations to context.SkinPace of change: Moderately fast (days to months)Focus: Design patterns, guidelines, and assetsSkin encompasses visual, interaction, and content design.Key contributors: Designers, content strategists, front-end developers, and user researchers.Design’s role: This is where designers’ traditional expertise shines. They craft the interface elements, establish visual language, define interaction patterns, and create the design systems that represent the product’s capabilities to users.Example actions/decisions/artifacts: UI component libraries, brand guidelines, prompt templates, tone of voice guidelines, navigation systems, visual design systems, patterns (UI, interaction, and conversation), content style guides.ServicesPace of change: Wildly variable (slow to moderately fast)Focus: AI computation capabilities, data systems orchestration, and operational intelligenceThe Services layer provides probabilistic AI capabilities that sometimes feel like superpowers — and like superpowers, they can be difficult to manage. It encompasses foundation models, algorithms, data pipelines, evaluation frameworks, business logic, and computing resources.Services is an outlier that behaves differently from the other layers:• It’s more prone to “shocks” and surprises that can ripple across the rest of the system.• It varies wildly in pace of change. (But its components rarely change faster than Skin, or slower than Skeleton.)• It cuts across multiple layers rather than sitting between two of them. That produces more cross-layer boundaries, more tension points, more risks of destructive friction, and more opportunities for constructive turbulence.Key contributors: Data scientists, engineers, service designers, ethicists, product teamsDesign’s role: Designers partner with technical teams on evaluation frameworks, helping define what “good” looks like from a human experience perspective. They contribute to guardrails, monitoring systems, and multi-agent collaboration patterns, ensuring technical capabilities translate to meaningful human experiences. Service design expertise helps orchestrate complex, multi-touchpoint AI capabilities.Example actions/decisions/artifacts: Foundation model selection, changes, and fine-tuning. Evals, monitoring systems, guardrails, performance metrics. Business rules, workflow orchestration. Multiagent collaboration and use of external tools (APIs, A2A, MCP, etc.) Continual appraisal and adoption of new tools, protocols, and capabilities.SkeletonPace of change: Moderately slow (months) Focus: Fundamental structure and organizationThis layer establishes the foundational architecture — the core interaction models, information architecture and organizing principles.Key contributors: Information architects, information designers, user researchers, system architects, engineersDesign’s role: Designers with information architecture expertise are important in this layer. They design taxonomies, knowledge graphs, and classification systems that make complex AI capabilities comprehensible and usable. UX researchers help ensure these structures fit the audience’s mental models, contexts, and expectations.Example actions/decisions/artifacts: Taxonomies, knowledge graphs, data models, system architecture, classification systems.ScopePace of change: Slow (months to years)Focus: Product requirementsThis layer defines core functional, content, and data requirements, accounting for the probabilistic nature of AI and defining acceptable levels of performance and variance.Key contributors: Product managers, design strategists, design researchers, business stakeholders, data scientists, trust & safety specialistsDesign’s role: Design researchers and strategists contribute to requirements through generative and exploratory research. They help define error taxonomies and acceptable failure modes from a user perspective, informing metrics that capture technical performance and human experience quality. Design strategists balance technical possibilities with human needs and ethical considerations.Example actions/decisions/artifacts: Product requirements documents specifying reliability thresholds, data requirements (volume, diversity, quality standards), error taxonomies and acceptable failure modes, performance metrics frameworks, responsible AI requirements, risk assessment, core user stories and journeys, documentation of expected model variance and handling approaches.StrategyPace of change: Very slow (years)Focus: Long-term vision and business goalsThis foundation layer defines audience needs, core problems to solve, and business goals. In AI products, data strategy is central.Key contributors: Executive leadership, design leaders, product leadership, business strategists, ethics boardsDesign’s role: Design leaders define problem spaces, identify opportunities, and plan roadmaps. They deliver a balance of business needs with human values in strategy development. Designers with expertise in responsible AI help establish ethical frameworks and guiding principles that shape all other layers.Example actions/decisions/artifacts: Problem space and opportunity assessments, market positioning documents, long-term product roadmaps, comprehensive data strategy planning, user research findings on core needs, ethical frameworks and guiding principles, business model documentation, competitive/cooperative AI ecosystem mapping.Practical examples: tension points between layersTension point example 1: Bookmuse’s timeline troubles(Friction between Sessions and Skin)Bookmuse is a promising new AI tool for novelists. Samantha, a writer, tries it out while hashing out the underpinnings of her latest time-travel historical fiction thriller. The Bookmuse team planned for plenty of Samantha’s needs. At first, she considers Bookmuse a handy assistant. It supplements chats with tailored interactive visualizations that efficiently track character personalities, histories, relationships, and dramatic arcs.But Samantha is writing a story about time travelers interfering with World War I events, so she’s constantly juggling dates and timelines. Bookmuse falls short. It’s a tiny startup, and Luke, the harried cofounder who serves as a combination designer/researcher/product manager, hasn’t carved out any date-specific timeline tools or date calculators. He forgot to provide even a basic date picker in the design system.Problem: Bookmuse does its best to help Samantha with her story timeline (Sessions layer). But it lacks effective tools for the job (Skin layer). Its date and time interactions feel confusing, clumsy, and out of step with the rest of its tone, look, and feel. Whenever Samantha consults the timeline, it breaks her out of her creative flow.Constructive turbulence opportunities:a) Present feedback mechanisms that ensure this sort of “missing piece” event results in the product team learning about the type of interaction pothole that appeared — without revealing details or content that compromise Samantha’ privacy and her work. (For instance, a session tagging system can flag all interaction dead-ends during date choice interactions.)b) Improve timeline/date UI and interaction patterns. Table stakes: Standard industry-best-practice date picker components that suit Bookmuse’s style, tone, and voice. Game changers: Widgets, visualizations, and patterns tailored to the special time-tracking/exploration challenges that fiction writers often wrestle with.c) Update the core usability heuristics and universal interaction design patterns baked into the evaluation frameworks (in the Services layer), as part of regular eval reviews and updates. Result: When the team learns about a friction moment like this, they can prevent a host of future similar issues before they emerge.These improvements will make Bookmuse more resilient and useful.Tension point example 2: MedicalMind’s diagnostic dilemma(Friction between Services and Skeleton)Thousands of healthcare providers use MedicalMind, an AI-powered clinical decision support tool. Dr. Rina Patel, an internal medicine physician at a busy community hospital, relies on it to stay current with rapidly evolving medical research while managing her patient load.Thanks to a groundbreaking update, a MedicalMind AI model (Services layer) is familiar with new medical research data and can recognize newly discovered connections between previously unrelated symptoms across different medical specialties. For example, it identified patterns linking certain dermatological symptoms to early indicators of cardiovascular issues — connections not yet widely recognized in standard medical taxonomies.But MedicalMind’s information architecture (Skeleton layer) was tailored to traditional medical classification systems, so it’s organized by body system, conditions by specialty, and treatments by mechanism of action. The MedicalMind team constructed this structure based on how doctors were traditionally trained to approach medical knowledge.Problem: When Dr. Patel enters a patient’s constellation of symptoms (Sessions layer), MedicalMind’s AI can recognize potentially valuable cross-specialty patterns (Services layer). But these insights can’t be optimally organized and presented because the underlying information architecture (Skeleton layer) doesn’t easily accommodate the new findings and relationships. The AI either forces the insights into ill-fitting categories or presents them as disconnected “additional notes” that tend to be overlooked. That reduces their clinical utility and Dr. Patel’s trust in the system.Constructive turbulence opportunities:a) Create an “emerging patterns” framework within the information architecture (Skeleton layer) that can accommodate new AI-identified patterns in ways that augment, rather than disrupt, the familiar classification systems that doctors rely on.b) Design flexible visualization components and interaction patterns and styles (in the Skin layer) specifically for exploring, discussing, and documenting cross-category relationships. Let doctors toggle between traditional taxonomies and newer, AI-generated knowledge maps depending on their needs and comfort level.c) Implement a clinician feedback loop where specialists can validate and discuss new AI-surfaced relationships, gradually promoting validated patterns into the main classification system.These improvements will make MedicalMind more adaptive to emerging medical knowledge while maintaining the structural integrity that healthcare professionals rely on for critical decisions. This provides more efficient assistants for clinicians and better health for patients.Tension point example 3: ScienceSeeker’s hypothesis bottleneck(Friction between Skin and Services)ScienceSeeker is an AI research assistant used by scientists worldwide. Dr. Elena Rodriguez, a molecular biologist, uses it to investigate protein interactions for targeted cancer drug delivery.The AI engine (Services layer) recently gained the ability to generate sophisticated hypothesis trees with multiple competing explanations, track confidence levels for each branch, and identify which experiments would most efficiently disambiguate between theories. It can reason across scientific domains, connecting molecular biology with physics, chemistry, and computational modeling.But the interface (Skin layer) remains locked in a traditional chatbot paradigm — a single-threaded exchange with responses appearing sequentially in a scrolling window.Problem: The AI engine and the problem space are natively multithreaded and multimodal, but the UI is limited to single-threaded conversation. When Dr. Rodriguez inputs her experimental results (Sessions layer), the AI generates a rich, multidimensional analysis (Services layer), but must flatten this complex reasoning into linear text (Skin layer). Critical relationships between hypotheses become buried in paragraphs, probability comparisons are difficult, and the holistic picture of how variables influence multiple hypotheses is lost. Dr. Rodriguez resorts to taking screenshots and manually drawing diagrams to reconstruct the reasoning that the AI possesses but cannot visually express.Constructive turbulence opportunities:a) Develop an expandable, interactive, infinite-canvas “hypothesis tree” visualization (Skin) that helps the AI dynamically represent multiple competing explanations and their relationships. Scientists can interact with this to explore different branches spatially rather than sequentially.b) Create a dual-pane interface that maintains the chat for simple queries but provides the infinite canvas for complex reasoning, transitioning seamlessly based on response complexity.c) Implement collaborative, interactive node-based diagrams for multi-contributor experiment planning, where potential experiments appear as nodes showing how they would affect confidence in different hypothesis branches.This would transform ScienceSeeker’s limited text assistant into a scientific reasoning partner. It would help researchers visualize and interact with complex possibilities in ways that better fit how they tackle multidimensional problems.Navigating the future with AI Pace LayersAI Pace Layers offers product teams a new framework for seeing and shaping the bewildering structures and dynamics that power AI products.By recognizing the evolving layers and heeding and designing for their boundaries, AI design teams can:Transform tension points into constructive innovationAnticipate friction before it damages the product experienceGrow resilient and humane AI systems that absorb and integrate rapid technological change without losing sight of human needs.The framework’s value isn’t in rigid categorization, but in recognizing how components interact across timescales. For AI product teams, this awareness enables more thoughtful design choices that prevent destructive shearing that can tear apart an AI system.This framework is a work in progress, evolving alongside the AI landscape it describes.I’d love to hear from you, especially if you’ve built successful AI products and have insights on how this model could better reflect your experience. Please drop me a line or add a comment. Let’s develop more effective approaches to creating AI systems that enhance human potential while respecting human agency.Part of the Mindful AI Design series. Also see:The effort paradox in AI design: Why making things too easy can backfireBlack Mirror: “Override”. Dystopian storytelling for humane AI designStay updatedSubscribe to be notified when new articles in the series are published. Join our community of designers, product managers, founders and ethicists as we shape the future of mindful AI design.AI Pace Layers: a framework for resilient product design was originally published in UX Collective on Medium, where people are continuing the conversation by highlighting and responding to this story.

LangGraph Multi-Agent Swarm is a Python library designed to orchestrate multiple AI agents as a cohesive “swarm.” It builds on LangGraph, a framework for constructing robust, stateful agent workflows, to enable a specialized form of multi-agent architecture. In a swarm, agents with different specializations dynamically hand off control to one another as tasks demand, rather than a single monolithic agent attempting everything. The system tracks which agent was last active so that when a user provides the next input, the conversation seamlessly resumes with that same agent. This approach addresses the problem of building cooperative AI workflows where the most qualified agent can handle each sub-task without losing context or continuity. LangGraph Swarm aims to make such multi-agent coordination easier and more reliable for developers. It provides abstractions to link individual language model agents (each potentially with their tools and prompts) into one integrated application. The library comes with out-of-the-box support for streaming responses, short-term and long-term memory integration, and even human-in-the-loop intervention, thanks to its foundation on LangGraph. By leveraging LangGraph (a lower-level orchestration framework) and fitting naturally into the broader LangChain ecosystem, LangGraph Swarm allows machine learning engineers and researchers to build complex AI agent systems while maintaining explicit control over the flow of information and decisions. LangGraph Swarm Architecture and Key Features At its core, LangGraph Swarm represents multiple agents as nodes in a directed state graph, edges define handoff pathways, and a shared state tracks the ‘active_agent’. When an agent invokes a handoff, the library updates that field and transfers the necessary context so the next agent seamlessly continues the conversation. This setup supports collaborative specialization, letting each agent focus on a narrow domain while offering customizable handoff tools for flexible workflows. Built on LangGraph’s streaming and memory modules, Swarm preserves short-term conversational context and long-term knowledge, ensuring coherent, multi-turn interactions even as control shifts between agents. LangGraph Swarm’s handoff tools let one agent transfer control to another by issuing a ‘Command’ that updates the shared state, switching the ‘active_agent’ and passing along context, such as relevant messages or a custom summary. While the default tool hands off the full conversation and inserts a notification, developers can implement custom tools to filter context, add instructions, or rename the action to influence the LLM’s behavior. Unlike autonomous AI-routing patterns, Swarm’s routing is explicitly defined: each handoff tool specifies which agent may take over, ensuring predictable flows. This mechanism supports collaboration patterns, such as a “Travel Planner” delegating medical questions to a “Medical Advisor” or a coordinator distributing technical and billing queries to specialized experts. It relies on an internal router to direct user messages to the current agent until another handoff occurs. State Management and Memory Managing state and memory is essential for preserving context as agents hand off tasks. By default, LangGraph Swarm maintains a shared state, containing the conversation history and an ‘active_agent’ marker, and uses a checkpointer (such as an in-memory saver or database store) to persist this state across turns. Also, it supports a memory store for long-term knowledge, allowing the system to log facts or past interactions for future sessions while keeping a window of recent messages for immediate context. Together, these mechanisms ensure the swarm never “forgets” which agent is active or what has been discussed, enabling seamless multi-turn dialogues and accumulating user preferences or critical data over time. When more granular control is needed, developers can define custom state schemas so each agent has its private message history. By wrapping agent calls to map the global state into agent-specific fields before invocation and merging updates afterward, teams can tailor the degree of context sharing. This approach supports workflows ranging from fully collaborative agents to isolated reasoning modules, all while leveraging LangGraph Swarm’s robust orchestration, memory, and state-management infrastructure. Customization and Extensibility LangGraph Swarm offers extensive flexibility for custom workflows. Developers can override the default handoff tool, which passes all messages and switches the active agent, to implement specialized logic, such as summarizing context or attaching additional metadata. Custom tools simply return a LangGraph Command to update state, and agents must be configured to handle those commands via the appropriate node types and state-schema keys. Beyond handoffs, one can redefine how agents share or isolate memory using LangGraph’s typed state schemas: mapping the global swarm state into per-agent fields before invocation and merging results afterward. This enables scenarios where an agent maintains a private conversation history or uses a different communication format without exposing its internal reasoning. For full control, it’s possible to bypass the high-level API and manually assemble a ‘StateGraph’: add each compiled agent as a node, define transition edges, and attach the active-agent router. While most use cases benefit from the simplicity of ‘create_swarm’ and ‘create_react_agent’, the ability to drop down to LangGraph primitives ensures that practitioners can inspect, adjust, or extend every aspect of multi-agent coordination. Ecosystem Integration and Dependencies LangGraph Swarm integrates tightly with LangChain, leveraging components like LangSmith for evaluation, langchain\_openai for model access, and LangGraph for orchestration features such as persistence and caching. Its model-agnostic design lets it coordinate agents across any LLM backend (OpenAI, Hugging Face, or others), and it’s available in both Python (‘pip install langgraph-swarm’) and JavaScript/TypeScript (‘@langchain/langgraph-swarm’), making it suitable for web or serverless environments. Distributed under the MIT license and with active development, it continues to benefit from community contributions and enhancements in the LangChain ecosystem. Sample Implementation Below is a minimal setup of a two-agent swarm: from langchain_openai import ChatOpenAI from langgraph.checkpoint.memory import InMemorySaver from langgraph.prebuilt import create_react_agent from langgraph_swarm import create_handoff_tool, create_swarm model = ChatOpenAI(model="gpt-4o") # Agent "Alice": math expert alice = create_react_agent( model, [lambda a,b: a+b, create_handoff_tool(agent_name="Bob")], prompt="You are Alice, an addition specialist.", name="Alice", ) # Agent "Bob": pirate persona who defers math to Alice bob = create_react_agent( model, [create_handoff_tool(agent_name="Alice", description="Delegate math to Alice")], prompt="You are Bob, a playful pirate.", name="Bob", ) workflow = create_swarm([alice, bob], default_active_agent="Alice") app = workflow.compile(checkpointer=InMemorySaver()) Here, Alice handles additions and can hand off to Bob, while Bob responds playfully but routes math questions back to Alice. The InMemorySaver ensures conversational state persists across turns. Use Cases and Applications LangGraph Swarm unlocks advanced multi-agent collaboration by enabling a central coordinator to dynamically delegate sub-tasks to specialized agents, whether that’s triaging emergencies by handing off to medical, security, or disaster-response experts, routing travel bookings between flight, hotel, and car-rental agents, orchestrating a pair-programming workflow between a coding agent and a reviewer, or splitting research and report generation tasks among researcher, reporter, and fact-checker agents. Beyond these examples, the framework can power customer-support bots that route queries to departmental specialists, interactive storytelling with distinct character agents, scientific pipelines with stage-specific processors, or any scenario where dividing work among expert “swarm” members boosts reliability and clarity. At the same time, LangGraph Swarm handles the underlying message routing, state management, and smooth transitions. In conclusion, LangGraph Swarm marks a leap toward truly modular, cooperative AI systems. Structured multiple specialized agents into a directed graph solves tasks that a single model struggles with, each agent handles its expertise, and then hands off control seamlessly. This design keeps individual agents simple and interpretable while the swarm collectively manages complex workflows involving reasoning, tool use, and decision-making. Built on LangChain and LangGraph, the library taps into a mature ecosystem of LLMs, tools, memory stores, and debugging utilities. Developers retain explicit control over agent interactions and state sharing, ensuring reliability, yet still leverage LLM flexibility to decide when to invoke tools or delegate to another agent. Check out the GitHub Page. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 90k+ ML SubReddit. Sana HassanSana Hassan, a consulting intern at Marktechpost and dual-degree student at IIT Madras, is passionate about applying technology and AI to address real-world challenges. With a keen interest in solving practical problems, he brings a fresh perspective to the intersection of AI and real-life solutions.Sana Hassanhttps://www.marktechpost.com/author/sana-hassan/ByteDance Introduces Seed1.5-VL: A Vision-Language Foundation Model Designed to Advance General-Purpose Multimodal Understanding and ReasoningSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Researchers from Tsinghua and ModelBest Release Ultra-FineWeb: A Trillion-Token Dataset Enhancing LLM Accuracy Across BenchmarksSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Coding Agents See 75% Surge: SimilarWeb’s AI Usage Report Highlights the Sectors Winning and Losing in 2025’s Generative AI BoomSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Rethinking Toxic Data in LLM Pretraining: A Co-Design Approach for Improved Steerability and Detoxification

In its latest executive guide, “Agentic AI – The New Frontier in GenAI,” PwC presents a strategic approach for what it defines as the next pivotal evolution in enterprise automation: Agentic Artificial Intelligence. These systems, capable of autonomous decision-making and context-aware interactions, are poised to reconfigure how organizations operate—shifting from traditional software models to orchestrated AI-driven services. From Automation to Autonomous Intelligence Agentic AI is not just another AI trend—it marks a foundational shift. Unlike conventional systems that require human input for each decision point, agentic AI systems operate independently to achieve predefined goals. Drawing on multimodal data (text, audio, images), they reason, plan, adapt, and learn continuously in dynamic environments. PwC identifies six defining capabilities of agentic AI: Autonomy in decision-making Goal-driven behavior aligned with organizational outcomes Environmental interaction to adapt in real time Learning capabilities through reinforcement and historical data Workflow orchestration across complex business functions Multi-agent communication to coordinate actions within distributed systems This architecture enables enterprise-grade systems that go beyond single-task automation to orchestrate entire processes with human-like intelligence and accountability. Closing the Gaps of Traditional AI Approaches The report contrasts agentic AI with earlier generations of chatbots and RAG-based systems. Traditional rule-based bots suffer from rigidity, while retrieval-augmented systems often lack contextual understanding across long interactions. Agentic AI surpasses both by maintaining dialogue memory, reasoning across systems (e.g., CRM, ERP, IVR), and dynamically solving customer issues. PwC envisions micro-agents—each optimized for tasks like inquiry resolution, sentiment analysis, or escalation—coordinated by a central orchestrator to deliver coherent, responsive service experiences. Demonstrated Impact Across Sectors PwC’s guide is grounded in practical use cases spanning industries: JPMorgan Chase has automated legal document analysis via its COiN platform, saving over 360,000 manual review hours annually. Siemens leverages agentic AI for predictive maintenance, improving uptime and cutting maintenance costs by 20%. Amazon uses multimodal agentic models to deliver personalized recommendations, contributing to a 35% increase in sales and improved retention. These examples demonstrate how agentic systems can optimize decision-making, streamline operations, and enhance customer engagement across functions—from finance and healthcare to logistics and retail. A Paradigm Shift: Service-as-a-Software One of the report’s most thought-provoking insights is the rise of service-as-a-software—a departure from traditional licensing models. In this paradigm, organizations pay not for access to software but for task-specific outcomes delivered by AI agents. For instance, instead of maintaining a support center, a business might deploy autonomous agents like Sierra and only pay per successful customer resolution. This model reduces operational costs, expands scalability, and allows organizations to move incrementally from “copilot” to fully autonomous “autopilot” systems. To implement these systems, enterprises can choose from both commercial and open-source frameworks: LangGraph and CrewAI offer enterprise-grade orchestration with integration support. AutoGen and AutoGPT, on the open-source side, support rapid experimentation with multi-agent architectures. The optimal choice depends on integration needs, IT maturity, and long-term scalability goals. Crafting a Strategic Adoption Roadmap PwC emphasizes that success in deploying agentic AI hinges on aligning AI initiatives with business objectives, securing executive sponsorship, and starting with high-impact pilot programs. Equally crucial is preparing the organization with ethical safeguards, data infrastructure, and cross-functional talent. Agentic AI offers more than automation—it promises intelligent, adaptable systems that learn and optimize autonomously. As enterprises recalibrate their AI strategies, those that move early will not only unlock new efficiencies but also shape the next chapter of digital transformation. Download the Guide here. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 90k+ ML SubReddit. Here’s a brief overview of what we’re building at Marktechpost: ML News Community – r/machinelearningnews (92k+ members) Newsletter– airesearchinsights.com/(30k+ subscribers) miniCON AI Events – minicon.marktechpost.com AI Reports & Magazines – magazine.marktechpost.com AI Dev & Research News – marktechpost.com (1M+ monthly readers) Partner with us NikhilNikhil is an intern consultant at Marktechpost. He is pursuing an integrated dual degree in Materials at the Indian Institute of Technology, Kharagpur. Nikhil is an AI/ML enthusiast who is always researching applications in fields like biomaterials and biomedical science. With a strong background in Material Science, he is exploring new advancements and creating opportunities to contribute.Nikhilhttps://www.marktechpost.com/author/nikhil0980/Multimodal AI Needs More Than Modality Support: Researchers Propose General-Level and General-Bench to Evaluate True Synergy in Generalist ModelsNikhilhttps://www.marktechpost.com/author/nikhil0980/This AI Paper Introduces Effective State-Size (ESS): A Metric to Quantify Memory Utilization in Sequence Models for Performance OptimizationNikhilhttps://www.marktechpost.com/author/nikhil0980/Huawei Introduces Pangu Ultra MoE: A 718B-Parameter Sparse Language Model Trained Efficiently on Ascend NPUs Using Simulation-Driven Architecture and System-Level OptimizationNikhilhttps://www.marktechpost.com/author/nikhil0980/Google Redefines Computer Science R&D: A Hybrid Research Model that Merges Innovation with Scalable Engineering