XTHE

Mobile technology is changing fast as the line between smartphones and wearables blurs. In early 2026, Google introduced the Android 17 secure companion API to unify wearable security. This update is more than a minor change for developers and manufacturers. it sets a new standard for biometric authentication in the Android ecosystem.  

The Problem of Peripheral Trust 

Until recently, connections between an Android device and a wearable such as a smart ring, augmented reality (AR) glasses, or a fitness tracker used loose protocols. Bluetooth, a short-range wireless technology, and Ultra Wide Band (UWB), a technology for accurate device positioning, provided the connection. Trust was managed by the wearable itself, sometimes poorly. The lack of consistency led to security gaps, especially as wearables began handling tasks such as payments, door unlocking, and accessing health records independently.  

The Android 17 Secure Companion API shifts the core trust point to the phone’s secure hardware. With a unified handshake, biometric checks on wearables are as secure as those on the phone itself, closing security gaps. AI wearables are no longer the weak link in digital security.  

Technical Architecture of the Secure Companion API 

The API uses Android 17 Strongbox, a secure hardware module for storing cryptographic keys, for remote biometric checks. The wearable sends an encrypted (encoded for security), salted (a random value added for greater security) biometric hash (a digital fingerprint of biometric data) to your phone.  

The host device, usually your phone, then performs the verification within its Trusted Execution Environment (TEE), which is a secure area of the main processor. If the signatures match, the host issues a short-lived trust token (a temporary digital credential) to the wearable, authorizing specific actions for a set duration. The architecture ensures that sensitive biometric templates are never permanently stored on the wearable itself, which is often more susceptible to physical tampering or theft than a smartphone.  

The API also adds a feature to maintain identity continuity. You stay logged in as long as your wearable is near your phone and in contact with your skin. If you remove a smart ring, the API cancels all trust tokens immediately. You need to re-authenticate with your biometrics.  

Standardized Biometrics for a Multimodal World. 

What makes the Android 17 secure companion API stand out is its flexibility. By 2026, biometrics will be more than just fingerprints. Now, things like how you walk or the rhythm of your voice can also be used to identify you.  

By providing a standardized interface, Google is enabling specialized hardware manufacturers to plug into Android’s security stack without having to write their own, often buggy, middleware. Whether a developer is working with a high-end medical-grade sensor or a consumer-grade gesture controller, the Secure Companion API provides a consistent set of calls to request authentication, check trust status, and handle secure key exchanges. This level of standardization is accepted to accelerate the adoption of invisible security, in which devices recognize who you are based on how you interact with them.  

Supporting The Next Generation Of AI Wearables 

The API release aligns with the AI wearable boom of late 2025, which brought more personal agents. These need access to emails, financial, and security systems. Without a standard for identity, agents remain limited to simple tasks.  

Thanks to the Android 17 Secure Companion API, AI-powered devices can now handle important tasks. For example, AR glasses could approve a wire transfer after checking your retinal scan, or a smartwatch could assign a legal document using your heart rate gun verified by your phone. This is the usefulness of a secure, standardized API.  

Privacy and the Zero-Knowledge Framework 

Privacy advocates have long raised concerns about the centralization of biometric data. In response, Google has implemented a zero-knowledge proof (ZKP) system in the secure companion API. This ensures that when your wearable and phone communicate, they verify your identity without exchanging raw biometric data. By keeping users’ biological data private and secure, Google aims to build trust, the trust necessary for the long-term success of AI wearables.  

Implementation and Developer Adoption 

For developers migrating to the secure companion API, it is designed to be relatively painless. The API works with Jetpack Compose for Wear and provides simple tools for managing complex cryptographic steps. Companies have reported significant reductions in development time. Offloading security logic to the Android OS allows companies to focus on core products, such as better health tracking, more immersive augmented reality, or more responsive AI agents. The API includes a compatibility layer for older hardware, so devices built in 2024 and 2025 can gain some of the security benefits of Android 17 through software-emulated trust zones.  

The Road Ahead: Toward a Passwordless Future 

The release of the Android 17 Secure Companion API is a big move toward a passwordless future. As our devices get smarter and more personal, we won’t need to rely on passwords anymore.  

In the next few years, the Secure Companion API is expected to support multi-device orchestration. You could log in once on your watch. That trust would extend to your tablet, laptop, and smart card. All would be managed by your Android 17 phone.  

Conclusion: A New Standard For Digital Intimacy 

By standardizing biometric authentication for AI wearables, Google is setting a clear standard for the wearable AI era, recognizing that security must be strong, unified, and privacy-focused.  

For developers, security researchers, and tech fans, the message is clear: old-isolated security models are gone. Now, there is a unified, hardware-backed, privacy-focused standard that will shape mobile technology for years to come. Android 17 is far more than an update. It sets the rules for the new era of wearable AI.

Source:  Android XR Bulletin—March 2026 

Apple Metal 4 now provides native low-latency neural scheduling for Mac GPUs, enabling developers to integrate AI features more efficiently.  

Developers can now run Core ML models directly on the GPU alongside graphics and compute workloads. Notable features include:  

• MTL4Macmachinelearning  

• command encoder  

• integrated tensor support  

• improved synchronization  

These enhancements allow AI workloads to operate independently of the CPU.  

Here are some important updates in Metal 4 for AI and Graphics 

• Native Neural Scheduling with MTL4 Machine Learning Command Encoder Machine Learning Inference can be integrated into the rendering pipeline.  

• Tensor support: The API and Metal Shading Language now have built-in Tensor support, making machine learning workflows smoother.  

• Optimized workflow: machine learning compute and rendering instructions can now be combined, reducing requirements for CPU-side synchronization.  

• Game Porting Toolkit 3.0: This version adds experimental Metal IFX integration and supports more instruction sets.  

• Game Porting Toolkit 3.0: This version adds experimental Metal IFX integration and supports more instruction sets.  

In summary, Metal 4 is designed for Apple silicon Macs and delivers advanced AI-powered graphics.  

With Metal 4, you can now run Core ML models efficiently as part of your Metal workflow. This helps when your app needs to use model output in a Metal context, for example, rendering a scene or running a compute task. To add machine learning inference, convert your Core ML model into a MetalML package during development. Then use that package in a machine learning encoder at runtime.  

Your app can handle rendering, compute, and machine learning tasks in a single command buffer, with no CPU wait or extra sync. When you run Core ML models on the GPU, your app sends inputs from a compute pass and quickly uses outputs from a machine learning pass.  

Metal 4 adds new tensor types, which are multi-dimensional arrays used for machine learning model data. The Digital Sharing language now includes tensor operators and features such as cooperative tensors. This lets your shader code work with tensor data in parallel at any GPU stage.  

Discover Metal 4 

Metal 4 is designed to fulfill the demands of today’s applications. Its simpler API helps you get the best performance on Apple Silicon with less overhead and enhanced resource management. Compilation is now clearer and faster, with new options to reduce runtime compilation.  

Metal 4 now fully supports machine learning, including native tensor support in the API and the Shading Language. You can add machine learning to your Metal application by running large networks from the command line or by adding inference operations immediately into your shader code.  

Metal 4 additionally extends the MTL device that you already use today. You can incrementally adopt features that will most help your app or game in the order you need them.  

Metal 4 Games 

Create modern games that work well on all Apple devices. Metal 4 helps you handle large sets of resources more efficiently. With new sparse resource placement, you can better utilize system memory. Also, use familiar APIs to quickly port your games from other platforms to Metal.  

The latest Metal compiler updates give you fine-grained control over shader compilation. Use a dedicated context to adjust the quality of service and ensure optimal performance. Quickly compile pipelines ahead of time to reduce run-time delays and share compilation results across render pipelines using a common Metal IR for faster development and testing.  

Go Further With MetalIFX And Ray Tracing 

Benefit from improved upscaling with integrated denoising for higher quality, sharper renders at high resolutions. Achieve higher frame rates using new frame interpolation, resulting in smoother animation without sacrificing visual quality.  

Ray tracing now uses intersection function buffers for more flexible indexing, simplifying porting ray tracing code to Metal. Flags for acceleration structure builds let you choose between faster intersection computation or smaller memory footprints, optimizing performance for your specific needs.  

Metal 4 Machine Learning 

You can now add machine learning to your metal application. Tensors are a native resource type for working with data. You can encode machine learning commands into the same Metal command buffers and use the same barriers to sync work on large networks. You can also embed inference directly into your shaders with Metal Performance Primitives, which are optimized for all Apple platforms.  

Game Porting Toolkit 3 

Evaluate even more gains with an expanded instruction set, sparse resources, and experimental support for Metal IFX upscaling, denoising, and frame interpolation. Build and debug your app remotely from Microsoft Visual Studio. Supercharge your HLSL shaders with access to Apple GPU features such as:  

• frame buffer fetch function constants  

• intersection function buffers  

using the Metal shader converter, and for access to all Metal APIs from C++ using Metal CPP.

Source: What’s new in Metal 

Reports from late 2025 and early 2026 show that Samsung is mass-producing the Exynos 2600 with its 2nd-generation 2NM gate-tolerant (GAA) transistor technology. Wells have improved to 50-60%. This progress means the chip can be used in the Galaxy S26 series, helping Samsung rely less on Qualcomm.  

Volume Production & Yield Status 

• Yield improvements: Samsung’s 2nm (SF2) reportedly started low (around 30% in early 2025) but increased steadily to ~40% by mid-2025 and reached 50-60% by the end of 2025, according to various reports.  

• Samsung officially began mass production of the Exynos 2600 in the last quarter of 2025. By early 2026, reports showed yields were stable enough for the Exynos 2600 to be used in the Galaxy S26 and S26 Plus models, while the Galaxy S26 Ultra is expected to use Qualcomm’s Snapdragon chips.  

• Initial production was about 15,000 wafers, and capacity is expected to grow as yields get better.  

New GAA Transistor Technology (SF2) 

The 2NM GAA process is a significant advancement, delivering measurable improvements in both power efficiency and performance compared to Samsung’s previous 3NM GAA process. For example, the 2NM process reduces energy consumption and increases chip operational speed compared to the 3NM variant.  

• Reports indicate the 2NM GAA process offers approximately a 5% performance improvement and 8% better power efficiency over the 3NM GAA process, making the newer node notably more efficient in real-world applications.  

• Specifically, the SF2 node provides up to a 12% increase in performance, 25% improvement in power efficiency, and 5% reduction in chip area compared to Samsung’s earlier 3NM nodes (SF3), offering tangible advantages for manufacturers and end users.  

• Advantage: Samsung is using its early experience with GAA technology, first introduced at 3nm, to stabilize the 2nm more quickly than before. Substack+32600 is designed to power the Galaxy S26 series in select markets (likely Europe and Korea), while the S26 Ultra is expected to continue using Qualcomm’s Snapdragon chips.  

• Achieving a 50 to 60% yield marks substantial progress for Samsung, but the company remains behind TSMC, which reports 2NM process yields of 60 to 70%. Samsung aims to stay competitive by offering lower prices.  

• Future outlook: If yields continue to rise, reaching 70% in 2026, Samsung could win back major foundry orders from big clients like Qualcomm.  

Samsung is advancing its semiconductor technology with the Exynos 2600, built using the company’s 2NM gate-all-around (GAA) process. Recent reports state that the trial production run achieved a 30% yield. While this represents a milestone for Samsung, it is still below TSMC’s 2NM yield, which is reported at about 60%.  

Why This Matters For Samsung 

The semiconductor industry is very competitive, and manufacturing efficiency directly affects profitability and cost management. Even though Samsung is still behind TSMC, reaching a 30% yield is a clear improvement, especially after its earlier difficulties with 3nm production. Higher yields mean more working chips per wafer, reducing unit costs and potentially improving profit margins. While 30% is still below the 70% that big customers like Qualcomm and MediaTek expect, it shows that Samsung’s semiconductor division is moving in the right direction, both financially and technically.  

Samsung’s Foundry business has struggled to gain the trust of major clients due to previous yield issues, particularly with its 4nm and 3nm nodes. Now the 2NM process offers the company a chance to rebuild its reputation. If yields continue to improve, Samsung could secure orders for flagship mobile processors, AI chips, and high-performance computing components in the near future.  

Exynos 2600, A Game Changer 

The Exynos 2600, also known as Ulysses, is expected to power Samsung’s next flagship devices and could help the company increase revenue through more premium smartphone sales. Right now, Samsung uses Qualcomm’s Snapdragon 8 Elite in its Galaxy S25 series, so improving its own chip production could lower supplier costs and boost overall profitability by reducing its reliance on outside vendors.  

Samsung has been trying to make its Exynos processors more competitive by improving power efficiency, thermal management, and overall performance. The 2NM GAA process brings major upgrades over the previous generation, offering higher transistor efficiency and greater performance per watt. Samsung’s progress in chip manufacturing could also impact AI, automotive, and data-center technology, not just smartphones. As the need for fast, power-efficient processors grows, producing advanced chips at scale will be key to Samsung’s long-term success.  

Difficulties and Opportunities 

Although reaching a 30% yield is meaningful progress, Samsung still faces significant challenges before it can compete directly with TSMC in large-scale chip production. The company needs to:  

• Improve Yield Efficiency: Achieving 70% yield is necessary to secure bulk orders from major tech companies.  

• Strengthening client trust, surmounting past production setbacks, and exhibiting consistency will help attract major customers.  

• Expand production capacity: ensuring that its facilities are ready for mass production without compromising quality will be vital for scaling up.  

• Advance GAA Technology: While Sachin is the head of TSMC, it must improve its GAA implementation to fully realize the benefits.  

Despite these challenges, Samsung’s ongoing investment in semiconductor research and infrastructure shows its determination to compete at the top level.  

What’s Next? 

Samsung plans to start mass production of its 2nm SF2 process in the second half of 2025. SF2 offers a 12% performance boost, 25% better power efficiency, and uses 5% less area compared to SF3. These technological upgrades could help Samsung compete for premium contracts, increase sales, and improve its financial position in high-end smartphones and advanced computing sectors.  

If Samsung can raise its yield to match TSMC’s, it could become a strong competitor in the foundry market again and win back market share. The company’s long-term aim is to become a player in semiconductor manufacturing, competing with TSMC and even Intel in the years ahead.  

While Samsung has a long way to go before its 2nm process becomes a commercial success, achieving a 30% yield is a step in the right direction. If the company continues upgrading its technology and manages costs and investments effectively, it may soon rival TSMC and secure major chip manufacturing contracts.  

The semiconductor competition is still ongoing, and with rapid technological progress, Things could start to favor Samsung. Keep watching as the race for semiconductor leadership continues.

Source: Samsung’s Exynos 2600 Hits 30% Yield on 2nm Process–A Step Toward Closing the Gap with TSMC 

Anthropic has updated its agentic development capabilities with the transition from the Claude code SDK to the Claude agent SDK in early 2026, providing native, advanced multi-agent orchestration designed for enterprise workflows. This SDK enables developers to build systems in which a central orchestrator agent delegates complex multi-step tasks to specialized sub-agents.  

Key Features of the Claude Agent SDK and Multitasking Routing  

The updated SDK supports building, deploying, and managing complex agentic workflows.  

• Native Multi-agent Orchestration: The framework enables the construction of hierarchies in which Claude Opus powers a main agent for delegating tasks to specialized subagents.  

• Persistent and autonomous: Unlike stateless API calls, the SDK operates a long-running process that can manage complex workflows, maintain conversational state across multiple queries, and execute demands in a persistent shell environment.  

• Model Context Protocol (MCP) integration: agents can seamlessly connect to external tools, data sources, and Internet databases, facilitating interoperability in enterprise environments.  

• Agent teams/subagents: the system supports agent teams (experimental as of early 2026), which allow multiple Claude code sessions to collaborate on shared tasks, with a lead session directing the workflow.  

• Production-Grade Controls: Includes built-in guardrails for granular permissions, allowing listing and working directory isolation.  

Enterprise AI Focus  

The shift to the Claude agent SDK supports the creation of specialized agents for various business domains.  

Specialized roles:  

• Co-op Development of legal assistance  

• Financial advisors and customer support bots  

• Codebase automation: Code agents capable of understanding and editing entire codebases, running bash commands, and managing git work trees  

• Integration with Enterprise Tools: The SDK supports integration with platforms like GitHub and allows for private plug-in marketplaces to enhance enterprise control.  

Technical Details And Availability  

• Languages: available for both Python and TypeScript  

• Migration developers are encouraged to migrate from Claude Code SDK to Cloud Agent SDK.  

• Commands: new agents. New agent SDK commands allow for defining workflows as code and managing multi-agent systems.  

Cloud now has research capabilities that allow it to search across the web, Google Workspace, and any integrations to accomplish complex tasks.  

The journey of this multi-agent system from prototype to production taught us critical lessons about system architecture, tool design, and prompt engineering. A multi-agent system consists of multiple agents (LLNs) working together in a loop, each using tools autonomously. Our research feature involves an agent that plans a research process based on user queries and then uses tools to create parallel agents that search for information simultaneously. Systems with multiple agents introduce new challenges in agent coordination, evaluation, and reliability. This post breaks down the principles that worked for us. We hope you will find them useful to apply when building your own multi-agent systems.  

Benefits of a Multi-agent System  

Research work involves open-ended problems where it is very difficult to predict the required steps in advance. You can’t hard-code a fixed path for exploring complex topics, as the process is inherently dynamic and path-dependent. When people conduct research, they tend to update their approach as discoveries emerge continuously and follow leads during the investigation.  

This unpredictability makes AI agents particularly well-suited for research tasks. Research demands the flexibility to pivot to or explore tangential connections as the investigation unfolds. The model must operate autonomously for many turns, making decisions about what directions to pursue based on immediate findings. A linear one-shot pipeline cannot handle these tasks.  

The essence of search compression: distilling insights from a vast corpus. Sub-agents facilitate compression by operating in parallel with their own context windows, exploring different aspects of the question simultaneously before condensing the most important tokens for the lead research agent. Each sub-agent also provides separation of concerns, distinct tools, prompts, and exploration trajectories, thereby reducing path dependency and enabling thorough, independent investigations. Once intelligence reaches a threshold, multi-agent systems become a virtual means of scaling performance. For instance, although individual humans have become more intelligent over the last 100,000 years, human societies have become exponentially more capable in the information age because of our collective intelligence and ability to coordinate. Even generally intelligent agents face limits when operating as individuals. Groups of agents can accomplish far more.  

Our internal evaluations show that multi-agent research systems excel, especially for breadth-first queries that involve pursuing multiple independent directions simultaneously. We found that a multi-agent system with Claude Opus 4 as the lead agent and Claude Sonnet 4 sub-agents outperformed single-agent Claude Opus 4 by 90.2% on our internal research eval. For example, when asked to identify all the board members of companies in the information technology S&P 500, the multi-agent system found the correct answers by decomposing the task into sub-agent tasks. In contrast, the single-agent system failed to find the answer through slow sequential searches.  

Meta agent systems work mainly because they have spent enough tokens to solve the problem. In our analysis, three factors explain 95% of the performance variance in the BrowseComp evaluation (which tests the ability of browsing agents to locate hard-to-find information). We found that token usage alone explains 80% of the variance, with the number of toll calls and the model choice as the other two explanatory factors. Finding validates our architecture, which distributes work across agents with separate context windows to increase parallel reasoning capacity. The latest Claude models act as large efficiency multipliers for token use, with upgrading to Claude Sonnet 4 yielding a larger performance gain than doubling the token budget on Claude Sonnet 3.7. Multi-agent architectures effectively scale token usage for tasks that exceed the limits of single agents.  

There is a downside: in practice, these architectures burn through tokens fast. In our data, agents typically use about 4x as many tokens per chat interaction, and multi-agent systems use about 15x as many tokens per chat. For economic viability, a multi-agent system requires tasks whose value is high enough to cover the increased performance cost. Further, some domains that require all agents to share the same context or involve many dependencies between agents are not well-suited to multi-agent systems today. For instance, most coding tasks involve fewer truly parallelizable tasks than research, and LLM agents are not yet great at coordinating and delegating to other agents in real time. We’ve found that multi-agent systems excel at valuable tasks that involve heavy parallelization in handling information beyond single-context windows and interfacing with numerous complex tools.  

Architecture Overview for Research  

Our research system uses a multi-agent architecture with an orchestrator working pattern, where a lead agent coordinates the process while delegating to specialized sub-agents that operate in parallel.  

When a user submits a query, the lead agent analyzes it, develops a strategy, and spawns sub-agents to explore different aspects simultaneously. As shown in the diagram above, the sub-agents act as intelligent filters by iteratively using search tools to gather information (in that case, on AI agent companies in 2025) and then returning a list of companies to the lead agent so it can compile the final answer.  

Traditional approaches to retrieval-augmented generation (RAG) rely on static retrieval. That is, they fetch a set of chunks that are most similar to an input query and use these chunks to generate a response. In contrast, our architecture uses a multi-step search that dynamically finds relevant information, adapts to new findings, and analyzes results to formulate high-quality answers.

Source:How we built our multi-agent research system 

NVIDIA CUDA Deep Neural Network Library (cuDNN) is a GPU toolkit for deep neural networks. The latest update optimizes implementations of key operations, including forward and backward convolutions  

• attention  

• matrix multiplication  

• pooling and normalization  

How cuDNN Works 

• Accelerated Learning: cuDNN uses computational kernels that leverage tensor cores when appropriate, delivering top performance for compute-bound operations. It also uses heuristics to select the optimal computational kernel for each problem size.  

• Fusion Support: cuDNN fuses compute-bound and memory-bound operations for common fusion problem patterns. It builds computational kernels at runtime. For specialized patterns, it leverages pre-optimized computational kernels.  

• Expressive op graph API command users represent computations as graphs of tensor operations. cuDNN provides both a direct C API and an open-source C++ front-end API, with most users starting with the front-end API.  

This Guide Covers Installing And Using The CuDNN Front End And Back End 

The NVIDIA cuDNN Deep Neural Network Library is a GPU toolkit for deep learning, offering optimized versions of common cuDNN operations such as:  

• Scaled dot Production attention  

• Convolution including cross-correlation  

• Matrix Multiplication  

• Normalizations, Softmax, and Pooling  

• Arithmetic, Mathematical, Relational, and Logical Point-wise Operations  

In addition to delivering fast operations, cuDNN lets you use flexible multi-operational fusion patterns for improved performance. This approach enables you to maximize the capabilities of NVIDIA GPUs for key deep-running tasks.  

cuDNN enables you to express both single-operation and multi-operation computations as operation graphs. You can build these graphs using the following API layers.  

• Python front-end API  

• C++ front-end API  

• C backend API  

NVIDIA cuDNN Python and C++ frontend APIs present a user-friendly, high-level programming model suitable for most scenarios, abstracting much of the complexity of lower-level GPU operations.  

Select the NVIDIA cuDNN backend API if you need access to routines not supported by the front-end APIs or if your application requires a pure C interface.  

Key Features 

Deep Neural Networks 

Deep learning neural networks are used in computer vision, conversational AI, and recommendation platforms. They have enabled advances such as self-driving cars, smart voice assistants, and NVIDIA GPU-accelerated frameworks that help train these models much faster, cutting training time from days to just hours.  

cuDNN provides more libraries for fast, low-latency inference with deep neural networks. It works in the cloud, on embedded devices, and in self-driving cars.  

• CuDNN accelerates key compute-bound operations, such as attention training, convolution, and matrix multiplication, while optimizing memory-bound operations, such as attention, decode, pooling, and normalization, through advanced fusions and heuristics.  

• Optimized Memory Bound Operations like:  

• Attention  

• Decode  

• Pulling  

• Softmax  

• Normalization  

• Activation  

• Pointwise  

• Tensor Transformation  

• Visions of Compute-Bound and Memory-Bound Operations  

• Runtime Fusion Engine to generate kernels at runtime for common fusion patterns  

• Optimizations for important specialized patterns like fused attention  

• Heuristics to choose the right implementation for a given problem size  

CuDNN Graph API and Fusion 

The cuDNN Graph API lets you describe and optimize common deep learning computation patterns by organizing operations as nodes and tensors. By treating edges in a data flow graph as first-class citizens, the API enables better performance, easier optimization, and greater flexibility for model developers than handling operations individually.  

You can use the cuDNN Graph API through the recommended Python or C++ frontend APIs, which provide high-level access. For legacy applications or when Python or C++ is not suitable, use the low-level C backend API for more direct control.  

• Flexible fusions of memory-limited operations into the input and output of matmul and convolution  

• Specialized fusions for patterns like attention and convolution with normalization  

• Support for both forward and backward propagation  

• Heuristics for predicting the best implementation for a given problem size  

• Open source Python/C++ frontend API  

• Serialization and deserialization support  

Ethically, the media sees trustworthy AI as a shared responsibility. We have established policies and practices to support a wide range of AI applications when using a model. Under our terms of service, developers should work with their teams to ensure the model meets industry needs and prevents misuse. misuse.  

Please report security vulnerabilities of NVIDIA AI concerns here.

Source: NVIDIA cuDNN 

OpenAI released an updated tool search API (Application Programming Interface, which allows different software to communicate) in March 2026. This update lets GPT agents (automated AI programs that act independently on tasks) find and load tool definitions as needed, saving tokens and enabling complex workflows to run more efficiently.  

Building on this, GPT 5.4 allows agents to handle larger tool sets and to dynamically select the required tools without upfront loading.  

Key Features and Capabilities 

This tool search upgrade aligns with other recent responses and API enhancements, all aimed at building stronger, more reliable AI agents.  

Main features include:  

• Dynamic tool loading allows models to load large tool schemas only when needed, reducing initial token use and costs for tool-heavy apps, while supporting enhanced agentic workflows for multi-step tasks and improved accuracy through relevant tool selection and reasoning.  

• Enhanced Agentic workflows. The system enables agents to plan, execute, and verify multi-step tasks more efficiently across different apps and data sources. Tools such as Web and File Searcher, and computer use enable them to access real-time information, analyze documents, and control computer interfaces.  

• Better accuracy: by using relevant tools and improved reasoning. Agents select tools and complete tasks more accurately per internal benchmarks.  

• Custom Tools Support: Developers can now make custom functions, namespaces (distinct naming systems for tools to avoid conflicts), or MCP (Multi-Channel Processing) servers searchable, allowing agents to connect with third-party services and private databases.  

Consequently, the update moves the API toward more sophisticated, long-running agent applications. Agents now enjoy more independence and can serve as reliable digital workers.  

In a related move, on Tuesday, OpenAI launched tools that let developers and businesses create AI agents automated programs powered by OpenAI’s models and frameworks to complete tasks independently.  

OpenAI’s new Responses API lets businesses build custom AI agents to search the web, review files, and browse websites. It will replace the Assistant API, which is scheduled to retire in early 2026.  

Interest in AI agents has increased in recent years, even though the tech industry still struggles to clearly define them or demonstrate their limitations. For example, earlier this week, the Chinese startup Butterfly Effect went viral for its new AI agent platform, Manus, but users soon found it did not deliver many of the company’s promised capabilities, highlighting new challenges with reliability and functionality.  

These developments increase expectations for OpenAI to deliver AI agents that reliably solve industry challenges and perform in real-world environments.  

It’s pretty easy to demo your agent, Oliver Godement, OpenAI’s product lead, told TechCrunch in an interview. Creating an agent is pretty hard, and getting people to use it is even harder.  

Earlier this year, OpenAI added two AI agents to ChatGPT Operator, which browses websites for you, and Deep Search, which creates research reports. While these tools demonstrated agent technology, they did not achieve full independence and still require significant improvement in reliability and autonomy.  

Now, with the responses of API, OpenAI is offering the building blocks behind its AI agents. Developers can use these to create their own apps similar to Operator and conduct deep research. Open AI works; this will lead to more independent-feeling AI applications than existing now. OpenAI hopes developers can tap into the same AI model (in preview) under the hood of its ChatGPT search tools, GPT-4O Search and GPT-4O Mini Search. The models can browse the web for answers to questions, citing sources as they generate replies.  

OpenAI reports that GPT-4-0 search and GPT-4-0 mini search are highly accurate on OpenAI’s Simple QA test for factual question answering. GPT-4-0 search scored 90%, and GPT-4-0 mini search scored 88%, while GPT-4.5 scored 63%.  

The responses API includes a file search utility that quickly scans company databases to retrieve information (OpenAI claims it won’t train models on these files). Developers can also use OpenAI’s Computer Using Agent (CUA), an AI that simulates mouse and keyboard actions, to automate tasks such as data entry and app workflows.  

Enterprises can optionally run the CUA (Computer Using Agent) model, which is being released in Research Preview, locally on their own systems. OpenAI said: “The consumer version of the CUA available within Operator can only take actions on the web.”  

It is important to note that the Responses API does not resolve all technical issues facing AI agents. While AI-powered search tools outperform traditional AI models in accuracy—unsurprisingly, as they can retrieve the correct answer, web search does not solve the hallucination problem. For example, GPT-4O Search still gets 10% of factual questions wrong.  

Beyond accuracy, AI search teams also tend to struggle with short navigation queries, such as ‘Lakers’ scores today’. Recent reports suggest that ChatGPT’s citations aren’t always reliable.  

OpenAI also acknowledges that the CU8 model is not yet reliable for automating operating system tasks and may make mistakes.  

However, OpenAI says these agent tools are still in the early stages and that the company is continually working to improve them.  

OpenAI is also launching an open-source agents SDK, giving developers tools to connect models, safeguards, and track agent activity. The SDK builds on OpenAI’s strong framework for managing multiple agents.  

Godement said he hopes OpenAI can bridge the gap between AI agent demos and products this year, and that, in his opinion, agents will be the most impactful application of AI. This repeats a proclamation made by OpenAI CEO Sam Altman in January that 2025 is the year AI agents enter the workforce.  

OpenAI’s newest tools show a clear shift: the company now prioritizes real usefulness and enterprise value over spectacle.

Source: OpenAI launches new tools to help businesses build AI agents