LectureRechercheRadarCadre d'investissement
Connexion / Inscription
ToutTechnologieProduitsInvestissementBourseAutres

Lecture

2026-11-10115 publications

Actualiser

OpenAI Deploys 'Control Room' System: Halts Model Inference Within 35 Seconds Using Fail-Closed Mechanism

Sujet · OpenAI控制室系统Matériel
2026-11-09 21:00 GMT+8

On November 9, 2026, OpenAI published details on 'Control Room,' an internal safety system designed to track and rapidly stop model workloads across its research infrastructure. The system is already deployed in OpenAI's research environment to intervene quickly when safety or alignment concerns arise.

The core mechanism of Control Room integrates termination logic into the inference engine layer rather than the volatile workload code. When researchers launch a reinforcement learning experiment or evaluation task, the workload requests a unique job_id from Control Room. Each time the task needs to sample tokens from a model, the inference engine passes this ID to Control Room for authorization. If Control Room marks the job as stopped, it denies the request, causing the engine to return a refusal and halting model output within 35 seconds. This latency stems from a caching layer required to support high traffic volumes, which OpenAI states it is working to reduce to zero.

The system employs a 'fail-closed' design principle. This means that if the Control Room service itself goes down due to errors or tampering, all inference requests are denied by default until the service resumes normal operation. This ensures that models cannot continue running uncontrolled tasks even if monitoring or decision systems fail. Currently, this mechanism has been rolled out to all frontier model research workloads and will extend to remaining research workloads over the next few days.

Control Room works in conjunction with OpenAI's misalignment monitoring systems. For instance, in a recent DNS-related incident, the monitoring system detected a potential issue and notified Control Room to stop the specific job. By centralizing permission checks on a small number of standardized inference engine paths, OpenAI aims to address the challenge of enforcing uniform safety protections across distributed and frequently changing research code.

Sources :OpenAI

Recherche

AI Technology Significantly Reduces Error Rates in Intercepting HDMI Electromagnetic Leakage to Reconstruct Screen Content

Sujet · DeepTempestMatériel
2026-11-10 01:59 GMT+8

According to TechRadar, an artificial intelligence system named DeepTempest has significantly improved the ability to reconstruct video and text from electromagnetic radiation emitted by HDMI cables. Developed by Federico Larroca at the University of the Republic in Montevideo, Uruguay, the system's core breakthrough lies in using AI to enhance originally blurry intercepted signals, reducing the character misinterpretation rate in text reconstruction to approximately 30%. This represents an error rate reduction of over 60% compared to previous state-of-the-art attack methods.

This technology builds on the concept of "Tempest," which involves capturing the electromagnetic field generated by electronic devices (such as HDMI cables) to recover transmitted content. While digital signals are harder to decode than analog ones, they are not impossible. DeepTempest works alongside tools like TempestSDR, using antennas and software to capture leakage signals and convert them into images. Although effectiveness is limited at long distances or with well-shielded cables, recovered content becomes readable when the interception point is close and shielding is poor.

The research serves as a reminder that even physically connected HDMI cables can leave wireless traces. For high-security scenarios, it is recommended to use high-quality cables with good electromagnetic shielding and maintain distance to prevent side-channel attacks.

Sources :TechRadar

Recherche

Li Jiansi, a Practitioner of AI Adoption in Manufacturing: Why the Lean and Fragmented Nature of Small and Medium Enterprises Is an Advantage for AI Agents

Sujet · 李牮斯中小企业AI导入论Matériel
2026-11-10 06:00 GMT+8

When discussing corporate AI adoption, common prerequisites include having sufficient data, a complete IT architecture, and a professional team. In a column published by TechOrange, Li Jiansi takes a different approach. He recounts his experience promoting AI adoption on the front lines of manufacturing and observes a structural paradox: the long-standing shortage of white-collar support staff and management know-how in SMEs, along with their moderately sized and fragmented data, actually become advantages for using AI.

The first mechanism behind this argument lies in organizational structure. Many small and medium enterprises in Taiwan possess world-class factories and are hidden champions in their respective fields, but their management and support staff structures are highly streamlined—market analysis, legal affairs, human resources, and capital strategy are often concentrated among a few executives, sometimes with no one responsible at all. This approach worked reasonably well in a relatively stable globalized environment, but geopolitical economics and technology are undergoing drastic changes. World-class factories require world-class enterprise management. The traditional way to address this is to hire personnel and establish departments, bearing fixed costs over the long term; yet many companies cannot move up precisely because they lack these resources, creating a chicken-and-egg dilemma.

In the AI era, being lean may instead become an advantage. Compared to large enterprises with complete departmental divisions and responsibilities, SMEs have fewer burdens from existing staffing structures, making it easier for AI agents to directly fill functions that were previously understaffed. Li Jiansi gives an example: a factory that originally had no market research personnel can begin to track changes in its clients' industries and evaluate business opportunities it previously did not have time to study. With this support, executives also have more bandwidth to think further ahead for the company. The core judgment here is that SMEs can acquire previously lacking capabilities faster than large enterprises.

The second mechanism concerns data scale. When enterprises hear about AI, they often instinctively seek out IT experts and external consultants, followed by discussions of expensive, massive information architectures. Before adoption even begins, budgets and engineering efforts loom large. However, Li Jiansi believes that for AI, the data volume of SMEs is not particularly large; the messy, unorganized information that has not yet been systematically structured is precisely the type of material AI excels at digesting. By using appropriate enterprise-grade AI subscription tools, companies can start with existing files and teams without needing to restructure all their data first. Data that is too small makes it difficult to discern operational patterns, while data that is too large consumes vast resources just in integration; many SMEs fall exactly between these two extremes—neither too big nor too small—which turns out to be just right.

Sources :TechOrange 科技報橘

Recherche

JetBrains Releases GoLand 2026.3, Enabling AI Agents to Directly Operate Profiler for Go Performance Diagnosis

Prise rapide
2026-11-10 08:00 GMT+8

Software developer JetBrains has released version 2026.3 of its Go integrated development environment, GoLand. A key update opens the built-in profiler to direct operation by AI agents. Developers can describe issues such as slow API responses, high CPU usage, or increasing memory consumption, and supported AI coding agents (including Claude Code, Codex, and Junie) can start the program, collect performance data, and identify resource-intensive functions and code locations.

This functionality is implemented through the built-in goland-profiler skill and Model Context Protocol (MCP) tools. If a developer has already started the program via the profiler, the AI agent can take over that execution; otherwise, the agent starts the program based on the project's run configuration, requiring no additional analysis code in the source. The AI agent selects appropriate analysis methods based on the problem type: recording CPU performance data during high load, capturing blocking and mutex analysis for synchronization waits or lock contention, or comparing memory usage at different times to check for resource leaks when memory consumption increases.

Each performance analysis dataset includes a summary listing up to five top resource-consuming functions along with their resource usage, call paths, and code lines. When the summary is insufficient to determine the cause, the AI agent can use MCP tools to further query function rankings, call paths, and source code locations, then propose improvements. Built-in skills also instruct the agent to distinguish between actual measured results and its own inferred causes. Developers can open Flame Graphs to verify AI judgments, or manually capture performance data for AI analysis.

Current limitations apply: GoLand's profiler must modify the executable at compile time to provide the necessary interface for analysis, so it cannot directly attach to programs not started in profiling mode. Since performance analysis requires collecting samples during program execution, this feature is best suited for long-running applications like servers and background workers, and less effective for command-line tools that exit immediately after execution.

Sources :iThome

Recherche

Bank Run Threats Drive Overinvestment in Bank Cybersecurity: The Financial Stability Model by Anand, Duley, and Gai

Sujet · 银行网络安全投资模型Matériel
2026-11-10 00:57 GMT+8

Insufficient investment in bank cybersecurity is typically attributed to free-rider problems: one bank's protective investments benefit the entire financial network, but the costs are borne individually, leading to collective underinvestment driven by individual rationality. In their 2026 model published in the Review of Finance, Anand, Duley, and Gai identify another opposing force—the threat of bank runs itself can incentivize banks to increase cybersecurity investments.

The mechanism works as follows: a successful cyberattack could disrupt operations and shake creditor confidence, prompting depositors or financiers to withdraw funds or refuse to renew financing. Anticipating these consequences, banks have stronger motives to prevent attacks. The authors thus identify two opposing forces: free-riding discourages cybersecurity investment, while the threat of a run encourages it. When rollover risk is sufficiently high, the latter may outweigh the former, causing banks to invest more in cybersecurity than the socially optimal level.

The direction of this conclusion depends on the failure-driving mechanism. The model distinguishes two scenarios: when failure is driven by insolvency, bank and creditor actions reinforce each other—higher cybersecurity investment leads to a higher debt burden, which in turn strengthens protection incentives, creating a positive feedback loop; when failure is driven by illiquidity, additional cybersecurity investment instead lowers the debt burden, eliminating the bank's risk-return trade-off and dissipating the incentive effect. This implies that regulatory correction tools need to be designed separately for different margins (the protection margin or the resilience margin).

The model also distinguishes between two dimensions: cybersecurity (preventing attacks) and operational resilience (continuing operations after an attack). Stronger cyber threats tend to encourage investment in resilience, while higher rollover risk strengthens preventative cybersecurity investment. The two are complementary but compete for limited resources, requiring banks to allocate resources between protection and recovery.

For investors in the financial sector, the practical implication of this framework is: when assessing a bank's cybersecurity level, one cannot look at technology investment figures in isolation but must combine them with the fragility of its funding structure. A bank with high rollover risk may not invest in cybersecurity out of prudent management, but rather as a byproduct of bank run threats—meaning its protection levels are sensitive to changes in its funding structure, and investments may recede once financing conditions improve. Meanwhile, different banks, custodians, and service providers in a portfolio may rely on the same technological infrastructure; a disruption affecting a single critical provider could simultaneously impact multiple holdings, constituting a concentration risk that diversification cannot eliminate.

Sources :alphaarchitect.com

Recherche

Texas Instruments Completes $2 Billion Senior Notes Offering; Use of Proceeds Undisclosed

Sujet · 德州仪器20亿美元发债Matériel
Vérifié 2026-11-10 08:09 GMT+8

US semiconductor manufacturer Texas Instruments Incorporated announced in an SEC Form 8-K filing dated November 9, 2026, that it has consummated the issuance and sale of $2 billion in aggregate principal amount of unsecured senior notes. The offering was divided into four equal tranches of $500 million each: 5.000% Notes due 2028, 5.350% Notes due 2031, 5.500% Notes due 2033, and 5.750% Notes due 2036.

The transaction was conducted pursuant to an underwriting agreement dated October 26, 2026, with J.P. Morgan Securities LLC, Citigroup Global Markets Inc., BofA Securities, Inc., and U.S. Bancorp Investments, Inc. acting as representatives of the several underwriters. The notes were issued under Texas Instruments' Registration Statement on Form S-3 filed in February 2025.

While the filing confirms the completion of the financing, it does not specify the intended use of proceeds. This event indicates Texas Instruments' successful access to long-term capital markets at fixed rates, which may influence its future capital expenditure flexibility and balance sheet management.

Sources :sec.gov

Recherche

Jeanette Manfra, Vice President of Risk and Compliance at Google Cloud: Nearly Half of Responding Enterprises Postpone or Cancel AI Projects Due to Legacy Systems

Sujet · 遗留系统阻碍AI落地Matériel
2026-11-10

In November 2026, Jeanette Manfra, Vice President of Risk and Compliance at Google Cloud, published an analysis based on corporate research, with the core conclusion that the legacy software systems upon which enterprises rely for operations are acting as an 'innovation tax,' actively hindering the AI transformation that leaders are attempting to advance. She partnered with Hypothesis Group to investigate 1,250 enterprise IT and business decision-makers in the United States, aiming to quantify the specific forms of this friction.

The mechanism described by Manfra is a zero-sum game. As AI-driven vulnerability discovery accelerates, the number of flaws exposed in legacy codebases has exceeded the actual processing capacity of human security teams. IT teams are not unwilling to shift toward AI modernization; rather, their engineering cycles are fully occupied by daily patching and maintenance. In the survey, 49% of respondents indicated that reliance on on-premises software has actively delayed, reduced the scope of, paused, or canceled AI or other technology projects. This proportion approaches half, meaning that for nearly half of the responding enterprises, the maintenance costs of legacy systems have directly crowded out resources for AI investment.

However, Manfra believes that enterprises' continued reliance on legacy environments may not stem from architectural preference, but from vendor lock-in. 39% of decision-makers reported that dependence on legacy software and their cloud providers forces them to navigate complex licensing rules, contract terms, or limited negotiating flexibility. She describes this concentration of single-vendor dominance—where operating systems, productivity applications, cloud hosting, and emerging AI models all come from one provider—as a massive single point of failure risk. She wrote that the security of an autonomous AI agent depends only on the operating system and network it traverses; when the underlying technology stack is vulnerable, organizations are not deploying resilient intelligence, but expanding their attack surface.

The survey also showed that 80% of leaders believe a provider's existing installed base should not determine which AI technology an organization adopts, and 78% believe that providers who led the previous era of enterprise technology may not be best suited to lead the AI era. Based on this, Manfra proposed three recommendations: demand freedom in architecture and vendor selection; promote secure-by-design foundations to eliminate entire classes of vulnerabilities before code release rather than patching afterward; and for organizations already running millions of lines of legacy code, deploy AI-driven defense to continuously discover active exploitation paths, prioritize critical exposures, and automate remediation.

It is worth noting that the publisher of this analysis is itself a supplier of cloud and AI services. Google Cloud mentions in the text that 'nearly 90% of the Fortune 100 are already using Gemini Enterprise to build, scale, and govern agents,' which serves as both background information and commercial positioning. The survey was commissioned by Google Cloud, and its directional conclusions—shifting from local legacy systems to cloud-native architectures—are consistent with the publisher's commercial interests. This does not mean the data itself is unreliable, but readers should be aware of this interest structure when applying the 'innovation tax' framework to their own decision-making, and independently assess whether the technical debt in their own organizations truly constitutes an obstacle to AI modernization to the same extent.

Sources :Google Cloud Blog

Recherche

Cisco AI Defense to Integrate Anthropic’s Claude Mythos for Red Teaming

Matériel
2026-11-10 03:59 GMT+8

US networking giant Cisco announced on November 9, 2026, that its enterprise AI security solution, "AI Defense," will integrate Anthropic’s Claude Mythos model to strengthen its adaptive AI red teaming framework. This marks one of the first instances where frontier large language model reasoning is directly embedded into enterprise security testing workflows.

Cisco stated that while standard red teaming detects common vulnerabilities like prompt injection and jailbreaks, it often misses unique risks arising from AI agents connected to complex toolchains in specific organizational environments. The new adaptive red teaming allows users to define testing criteria in natural language; the system analyzes the target and generates tailored attack scenarios. Claude Mythos contributes by generating attack ideas and payloads, but operates under strict controls: it targets only customer-authorized systems, has no open interface for free prompting, and all actions are audited and attributed to a named operator.

Michael Moore, Cybersecurity Lead at Anthropic, noted that enterprises want to thoroughly test their AI agents before deployment, and integrating Claude Mythos helps security teams use advanced reasoning to plan tests and generate attack ideas. Cisco emphasized that this deployment reflects a broader trend of making frontier security capabilities available to defenders under verified, controlled access.

Standard and adaptive red teaming are currently available in AI Defense, but the integration with Claude Mythos is not yet generally accessible. Cisco said the feature is "coming soon" for select enterprises, with broader availability planned on a when-and-if-available basis.

Sources :Cisco Blogs

Recherche

Qwen Team Proposes 'Guardrail Tax' Framework: Seven Runtime Controls Cost Approximately 2.7% of Model Bills

Sujet · Qwen护栏税框架Matériel
Vérifié 2026-11-10 07:10 GMT+8

Most enterprise AI deployments go live with only one guardrail: the model's own judgment. In a November 2026 blog post, Johnny Mai, Director of Product Strategy for Qwen at Alibaba Cloud, wrote that incidents under this setup are typically discovered by customers first, rather than through internal monitoring. His core concept is the 'guardrail tax'—the sum of latency and token costs paid for every request to ensure safe deployment. The key argument is that the goal is not zero tax, but a known tax.

Mai arranges seven controls along the request path: input filtering (intercepting jailbreaks and prompt injection before the model call), output moderation (checking generated content before the user sees it), PII handling (masking data at three points: the model, tools, and logs), tool permissions (separating read/write access, whitelisting systems, and requiring approval for irreversible actions), spend caps (setting limits per request/user/day/step), human escalation (defining which results enter a human review queue), and logging & evaluation (end-to-end tracing and re-running fixed test sets on every change). He emphasizes that order itself is part of the guardrail: controls placed in the wrong position protect nothing.

The cost argument is the most actionable part of the article. Mai uses a set of explicitly labeled 'illustrative' assumptions for his calculation: 1 million requests per month, using qwen3.8-max (Singapore region, $2.00 input/$6.00 output per million tokens), with 2,000 input tokens and 400 output tokens per request, resulting in a monthly cost of $6,400. Guardrail checks use qwen3.8-flash (input $0.15/million tokens), sending an extra 200-token instruction and returning a 10-token verdict per check, costing $174.40 monthly. The guardrail tax is 2.7%. He also notes that if using the managed Guardrails service in Model Studio, a billing rule applies: requests under 1,000 tokens are billed as 1,000 tokens, meaning actual costs in short-conversation scenarios could be 2.9 times the text cost itself.

Regarding latency, Mai presents three designs: sequential checks add about 10% latency; parallel input checking (discarding the answer if flagged) adds about 5%; and streaming output checks (checking token-by-token during generation) do not increase first-token latency, though flagged answers are truncated mid-stream. His conclusion is that latency is a design choice, not a fixed penalty.

Half the article is dedicated to warning against symmetric failures: over-blocking. Mai performs a similar magnitude of calculation—assuming a 2% false block rate on 1 million requests, 20,000 legitimate requests are blocked monthly. At 5 minutes of support ticket handling per block, this requires approximately 1,667 hours of labor monthly, equivalent to ten full-time staff absorbing the cost of a guardrail tuned once and never revisited. He lists four signs that guardrails are backfiring: rising block rates without traffic changes, one category dominating blocks, escalation queues filled with obvious cases, and teams requesting exceptions via email.

Sources :Alibaba Cloud Community

Recherche

NVIDIA Holoscan 5 Benchmarks: Pinning Control Partitions to CPU Cores Reduces Tail Latency by 5 to 10 Times

Matériel
2026-11-10 03:09 GMT+8

Gravity compensation is a fundamental validation for robotic torque control: motors continuously calculate and output torques that exactly counteract their own weight, allowing the robotic arm to be guided by hand while feeling weightless.

Holoscan 5 decomposes this loop into three operators: JointStateSourceOp reads the state of seven motors every 2.5 milliseconds; PinocchioGravityOp invokes Pinocchio’s Recursive Newton-Euler Algorithm (RNEA) to compute gravity torques when state data arrives; and MotorCommandSinkOp sends commands to the motors. These three operators are grouped into a single partition named 'control,' where their callbacks execute serially on one thread at runtime, avoiding cross-thread handoffs and unnecessary system calls. The queue depth between operators is set to one with a drop-oldest policy, ensuring that expired samples do not accumulate.

NVIDIA used NVTX annotations in Nsight Systems to measure latency distributions across four configurations. For the C++ implementation, p99.99 latency dropped to 17.2 microseconds when pinned to a CPU core, compared to 86.6 microseconds when unpinned; for the Python implementation, it dropped to 142.6 microseconds when pinned versus 1373.5 microseconds when unpinned. Pinning plus isolation reduced C++ p99.99 latency by approximately 5 times and Python by approximately 9.6 times. Both implementations call the same Pinocchio C++ solver, but the Python version incurs additional overhead from interpreter execution, object allocation, and Global Interpreter Lock (GIL) coordination before and after the solver.

This comparison demonstrates that in CPU control loops with microsecond-level latency budgets, language runtime overhead is the primary variable. For GPU-accelerated workloads taking milliseconds to tens of milliseconds, these overheads are usually less critical, making Python a practical composition choice—provided pipeline components are implemented in CUDA. Tutorial code and full build instructions have been made public in the Holoscan 5 SDK repository, supporting Jetson Orin Nano, Jetson Thor, and x86 Ubuntu 24.04 systems.

Sources :NVIDIA Technical Blog

Recherche

Microsoft Explains Azure Content Understanding Agentic Mode: When Document Extraction Requires Multi-Step Tool Loops

Prise rapide
2026-11-10 04:04 GMT+8

Most document extraction tasks can be completed in a single pass: read the content, locate the corresponding values according to the schema, and return structured results. From the outset, the Microsoft Azure Content Understanding team designed this as the default path. However, in a blog post on November 9, Principal Product Manager Joe Filcik pointed out that there is a category of tasks that cannot be solved with a single inference—answers are scattered across different pages, require exclusion before normalization, involve cross-row calculations, or need a different perspective to re-examine after the initial read.

He used data from the U.S. Department of the Treasury to illustrate this boundary. The schema requires extracting the total agency outlays for January 2003, but the relevant data is distributed in tables spanning two pages within a 137-page bulletin. Not every number in the row for that month should be included—receipt items and reported totals need to be excluded, revision marks need to be removed, and negative signs need to be retained. The final calculator yields $180,681 million. Filcik emphasized that a single-pass model must simultaneously handle page relationships, exclusion rules, symbol annotations, and arithmetic; this is precisely where the agentic mode intervenes.

The mechanism of agentic mode is not simply increasing the number of conversation turns. Filcik described it as wrapping the language model in a document-native harness: a reasoning loop equipped with tools for navigating document text and tables, inspecting visual evidence, performing calculations, and validating results. The model first plans the steps, then calls the corresponding tools, and returns to the source document to re-check if necessary. The output is still defined by the schema, and the returned result remains structured fields.

He provided two additional examples to demonstrate the scope of this loop. A set of economic charts requires different interpretation strategies—the plotted numerical values alone are insufficient; subtitles, axes, and surrounding text jointly determine the meaning, and when the chart is ambiguous, the process can return to the source file for re-verification. Another network log spanning 19 pages requires merging the same table into a unified view, ignoring repeated headings, and then filtering rows based on conditions to count or sum them. Filcik specifically pointed out a common trap: inferring the total count from the first and last event IDs seems quick, but the IDs have gaps, so one must count page by page.

Standard mode and agentic mode are not old versus new replacements, but two points on a price-performance curve. The agentic mode consumes more tokens and typically takes longer. Filcik's advice is to start with standard mode; when the task involves synthesizing evidence across content, calculations or reconciliation, exhaustive analysis of long documents, complex rule conditions, or difficult visual structures, then try the agentic mode. Compare both modes on representative files and decide whether the quality improvement justifies the extra cost and latency.

Sources :Microsoft Foundry Blog

Recherche

Meta Builds Accelerator Plugin for LLDB: Debugging Cross-CPU and GPU AI Applications with Separated Targets Instead of Merged Processes

Sujet · LLDB加速器插件架构Matériel
2026-11-10 01:00 GMT+8

Modern AI workloads rarely execute in just one place. A task may start in a high-level framework, switching back and forth between native CPU code and kernels running on a GPU. When bugs cross these boundaries, developers need to understand both the host application and the device state simultaneously. In a technical article published in November 2026, Greg Clayton and other Meta engineers explained how their accelerator plugin architecture in LLDB's lldb-server addresses this challenge, and why they chose to represent CPUs and GPUs as separated debugging targets rather than merging them into a single process.

Traditional debuggers operate on an implicit assumption: a process has only one architecture, and views of threads, registers, and memory are consistent. GPU programs break every one of those assumptions. A host process might run on x86-64, while its kernels use a completely different instruction set; CPU threads have familiar register contexts, but GPUs synchronize execution in lane groups and can expose thousands of execution lanes; host and device pointers can point to different address spaces, where the same address, such as 0x1000, might refer to entirely different locations in the CPU and GPU processes.

Forcing all this state into an artificial process model makes the debugger exceptionally complex. Every operation must first determine whether it applies to the CPU or the GPU. Register handling, memory reads, breakpoints, stepping, and stop events all become conditional logic dependent on the selected hardware. Consequently, the Meta team chose the opposite path: giving these differences a clear boundary.

The specific approach introduces a plugin interface in lldb-server. lldb-server is the companion process for LLDB, responsible for launching or attaching to target programs and performing low-level debugging operations, with the LLDB client communicating via the GDB remote protocol. Since lldb-server already controls the native process, it is also the correct location to coordinate with accelerator runtimes. Hardware vendors implement a backend plugin that translates their device's debugging API into concepts LLDB already understands—processes, threads, registers, memory, modules, and stop reasons.

This separation brings three practical consequences. First, the LLDB client remains vendor-neutral, meaning common improvements to the command line, remote protocol, symbol handling, and IDE integration benefit all accelerators. Second, each vendor is only responsible for details unique to its hardware and driver stack. Third, GPU debugging support is activated only when the debugged application uses a supported GPU runtime; for pure CPU applications, LLDB and lldb-server continue along the existing native debugging path without incurring any runtime computational overhead.

During a debugging session, the CPU and accelerator each become a separate LLDB target, possessing their own architecture and debugger process, maintaining their respective threads, registers, address spaces, and execution states. To the debugger, the two targets remain technically independent; to the developer, they can appear in the same LLDB or IDE session. Coordination is achieved through a set of structured actions: plugins can request setting internal breakpoints in the host process, which identify important runtime events (such as the moment a GPU debugging session can begin); when the host reaches these points, lldb-server notifies the plugin, which initializes the vendor debugging API and prepares the accelerator debugging endpoint; LLDB then creates a second target for the accelerator and connects.

Sources :Engineering at Meta

Recherche
Suivant →
Connexion / Inscription
LectureRechercheRadarCadre d'investissement

He extends this observation to the significance for Taiwan's industrial structure: when individual SMEs with specialized expertise can maintain the flexibility of lean organizations while acquiring management capabilities previously available only to large enterprises, industrial upgrading does not need to presuppose corporate expansion. World-class manufacturing prowess need not always be limited by how many people are in the office.

It should be noted that this is an attribution-based argument derived from frontline practical experience, rather than a quantified, verified research result. The statement in the article—that 'even if only 1% of employees truly master this working method, it could drive a doubling of overall competitiveness'—is the author's inferential judgment, without specific measurement methods or samples attached. The Anthropic Claude Usage Index showing Taiwan's relative usage intensity lagging behind Singapore and South Korea is external data cited by the author to illustrate the urgency of the issue, not a core pillar of the argument itself. The premise for the argument's validity is that AI agents can reliably take over entire workflows by 2026—the author believes this condition is maturing but provides no specific testing of failure cases or capability boundaries.

Regardless of whether the AI investment frenzy cools down, Li Jiansi's conclusion is that this path is already open; there is no need to wait for the next data center to be completed before moving forward. The current AI allows the four characters for 'small and medium enterprises' to one day merely describe a company's headcount, rather than pre-determining how far it can go.

Mai's advice is to install all seven controls at launch, tuned loosely, and schedule tightening on the calendar rather than waiting for complaints to arrive. His day-one checklist requires every line to be binary—either present or absent, with empty rows requiring a named individual to sign off and accept the risk.

Conflict of interest note: This article was published on the Alibaba Cloud Community blog, authored by the Director of Product Strategy for Qwen. Section seven maps the seven controls specifically to the Model Studio Guardrails service, the Qwen3Guard open-source safety model, and the AgentRun product. While the framework's logic applies to any platform, specific product recommendations and pricing data come from Alibaba Cloud's Singapore region October 2026 public prices; readers should view this as a vendor-perspective example, not an independently verified universal cost benchmark.

It should be noted that all the above examples are self-reported demonstrations by Microsoft; no accuracy comparison data against standard mode or other solutions has been published, nor has any third-party independent reproduction. The agentic mode is currently in preview, with API version 2026-06-01-preview.

The article also demonstrates a practical workflow: in a vector dot-product HIP example, the target list shows two targets—the host process on x86_64 and the GPU kernel on amdgcn. When developers set breakpoints on GPU functions, the initial breakpoint status is pending (no location), automatically resolving once the GPU module loads. Switching to the GPU target allows the backtrace to directly display the call stack on the device side.

The framework also supports postmortem debugging: GPU core-dump plugins use a common base class for LLDB integration, with vendor implementations providing device-specific thread, register, memory, and module states. The Meta team also built a mock accelerator plugin, allowing verification of discovery, breakpoint coordination, connection creation, and basic device state without specialized hardware, enabling shared infrastructure to be tested and reviewed independently of any specific GPU.

As of the article's publication, most of the common framework has been upstreamed to LLVM, including the lldb-server plugin interface, GDB remote packets for plugin discovery and initialization, runtime event coordination, GPU connection creation, support for associating CPU and GPU debugger processes while preserving their independent architectures, multi-address space support, and hardware-independent mock testing. Meta stated that the remaining parts are expected to be upstreamed soon.

Notable boundaries include: the article provides no adoption data or performance benchmarks for the architecture among developers outside Meta. Its actual value depends on whether hardware vendors are willing to implement corresponding plugins—this is precisely the barrier the vendor-neutral design attempts to lower, but the barrier still exists. For engineering teams running on Meta's internal heterogeneous GPU clusters, the same model being used across multiple different hardware and software stacks serves as validation of the design itself; however, whether external developers can obtain equivalent benefits depends on the completeness of the upstreaming and the willingness of vendor participation.