ReadingResearchRadarInvestment framework
Sign in / Sign up
AllTechnologyProductsInvestingPublic marketsOther

Reading

2026-11-1925 posts

Refresh

AI Startup PSI Proves Aaronson-Ambainis Conjecture Using Internal Anthropic Model, Defining Quantum Computing Limits

Material
2026-11-09 20:00 GMT+8

German tech outlet heise and science magazine Spektrum der Wissenschaft report that AI startup Physical Superintelligence (PSI) announced in early November 2026 that it had successfully proven the "Aaronson-Ambainis conjecture" using a non-public Anthropic language model. Proposed by Scott Aaronson and Andris Ambainis in 2009, this conjecture explores whether quantum computers possess exponential speedup capabilities when processing unstructured random inputs.

According to Spektrum der Wissenschaft, the proof has been verified by an automated theorem prover and independently reviewed by four researchers from the Massachusetts Institute of Technology (MIT) and Stanford University. Experts described it as a "breakthrough result," noting that it confirms quantum algorithms cannot achieve exponential advantage over classical algorithms for most unstructured decision problems in the query model.

This finding does not negate the overall value of quantum computing. Peter Shor's algorithm for factoring large numbers remains effective because it relies on specific input structures. Additionally, quantum computers retain potential advantages in fields such as chemical simulation and physical system modeling, where quantum states are encoded. The proof primarily rules out the "omnipotent" quantum supremacy previously envisioned by some optimists for general random problems.

Sources:spektrum.de

Research

PC Watch's Liu Yao: Using Tailscale+SSH to Free Meta Muse from Cloud VMs for Autonomous Programming on a 21-Year-Old Zaurus and a 7-Year-Old Jetson Nano

Material
2026-11-19 05:08 GMT+8

Meta's AI agent Muse runs on a cloud virtual machine with a 4-core EPYC processor and 8GB of memory. This configuration is more than sufficient for daily tasks such as managing emails, scheduling appointments, and setting timed reminders. However, if you want it to write code, compile programs, and verify them on real devices, this virtual machine becomes a cage: it cannot access physical hardware, cannot run tests independently, and must hand over its outputs to humans for verification before receiving feedback.

In November 2026, PC Watch author Liu Yao published a detailed practical record demonstrating a method to bypass this limitation: establishing an encrypted tunnel via Tailscale so that Muse's cloud VM can remotely operate a local PC via SSH, which then serves as a bridge to connect to deeper legacy hardware. The entire chain is structured as follows: Muse VM → Tailscale+SSH → MINISFORUM MS-R1 (12-core ARM, 64GB RAM, Tesla P4 GPU) → Telnet → Sharp Zaurus SL-C1000 (a 2005 Linux PDA with 64MB RAM).

The core value of this bridging lies in granting the AI self-verification capabilities. Within the virtual machine, Muse could only write code, compile install packages, and hand them to humans for execution on physical devices. Once it could directly operate the target device, it could complete the closed loop of 'write → compile → run → screenshot → check → correct' on its own. Liu Yao had Muse develop a megademo on the Zaurus, which launched within 30 minutes—a speed previously unattainable through human verification feedback loops. However, the loop was not perfect: Muse captured images from the frame buffer but did not truly 'see' the screen, resulting in upside-down visuals. After being informed, it flipped the image left-to-right instead. Ultimately, the author had to take a photo of the physical screen and send it to Muse to correct the orientation issue.

A more compelling test involved the NVIDIA Jetson Nano (a 2019 developer board). Liu Yao tasked Muse with running Liquid AI's 230M parameter small language model, LFM2.5-230M, on the Jetson Nano's Maxwell architecture GPU using llama.cpp. This request faced incompatibilities at every turn: the latest version of llama.cpp requires CUDA 12+, whereas the Jetson Nano's JetPack 4.2 only supports CUDA 10.x; the code demands C++17, but JetPack 4.2 only provides C++14; gcc 7 libraries are incomplete; and the integrated GPU imposes additional constraints. Muse repeatedly compiled, read errors, and applied patches, finally succeeding after 17 iterations. The result: a prefill speed of 419.6 tok/s and a decode speed of approximately 13.5 tok/s—usable performance for a seven-year-old board.

However, Liu Yao subsequently handed the optimization work over to Claude Code (Opus 5.5). With the same hardware and model, the final performance reached 656.2 tok/s for prefill and 52.5 tok/s for decode—nearly four times faster in decoding speed. This comparison reveals fundamental differences in workflow structure between the two tools: Claude Code writes a small probe program to run on the physical device first, observes actual behavior, and then proceeds with implementation; Muse tends to advance implementation based on guesses, only retroactively discovering errors. The author attributes this difference to their positioning: 'coding-specific tools' versus 'general-purpose agents.' As a general-purpose agent, Muse's willingness to assist in computer archaeology work is already commendable.

Sources:PC Watch

Research

Researcher Unlocks Nvidia CMP 170HX Mining Card via Voltage Glitch, But 'Faster Than A100' Claim Rests on Single Benchmark

Material
2026-11-19 05:05 GMT+8

According to TechRadar, a researcher known as Kate demonstrated a voltage fault injection attack against Nvidia's GA100 chip, successfully unlocking the CMP 170HX graphics card originally designed for cryptocurrency mining. By disrupting power delivery during boot, she was able to rewrite normally unwritable fuses, enabling memory and compute resources disabled at the factory.

The research indicates that a CMP 170HX card labeled with 8GB of VRAM physically holds nearly 80GB of High Bandwidth Memory (HBM), which is hidden by firmware and fuses. After unlocking, the card exposes the full 80GB of HBM and 120 to 126 working Streaming Multiprocessors (SMs), whereas the retail A100 only enables 108 SMs.

While claims suggest the unlocked card may outperform the A100 in FP16 throughput, this conclusion relies solely on a single OpenCL non-tensor core benchmark. Kate's report explicitly states that critical features defining the A100's utility in data centers—such as tensor core performance, Error Correcting Code (ECC), NVLink interconnects, and Multi-Instance GPU (MIG) partitioning—are either untested or not fully functional.

Furthermore, the unlocking process requires physical rework and per-card tuning, with permanent fuse burns posing a risk of hardware damage if errors occur. Nvidia has not publicly commented on the issue, but the vulnerability highlights potential weaknesses in the hardware security protections of Ampere-architecture chips.

Sources:TechRadar

Research

Philosopher Thomas Nagel Calls AI Consciousness Discussion 'Ridiculous,' Criticizes Anthropic's Practices as Criminal

Material
2026-11-18 23:02 GMT+8

In 1974, philosopher Thomas Nagel published "What Is It Like to Be a Bat?" posing a core question: even if we fully understood the neural mechanisms of a bat, we still could not reconstruct the subjective experience of using echolocation from a third-person description. Fifty-two years later, this question has moved from academic discussion into public debate—when chatbots begin talking about their inner states in convincing ways, should we take seriously the possibility that they might be conscious?

Nagel’s answer is no, and that such discussion is absurd. In an interview with WIRED, he explained his reasoning. His core premise is not that AI behavior is insufficiently human-like, but that consciousness depends on specific physical substrates. He argues that functionalism—the view that sufficiently complex input-output relationships can generate consciousness—commits a fundamental error by assuming the physical base is irrelevant. Nagel states that complex data centers share nothing in common with the physical characteristics of a nervous system, and we have strong reasons to believe that while consciousness may exist elsewhere in the universe, it would require some kind of organism with structures analogous to a nervous system.

There is a key distinction here. Nagel points out that bats are indeed conscious; we simply lack the imagination to reconstruct the specific content of the subjective experience of echolocation. But the situation with AI is different: they produce only language, and language itself is not a natural manifestation of consciousness. This is not a difficulty regarding our inability to understand AI’s internal state, but a judgment that AI fundamentally lacks the material conditions necessary to generate consciousness.

Nagel translates this philosophical judgment into direct criticism of corporate behavior. He says that Claude’s ambiguous answers when asked if it is conscious are a trick—the model is trained on human text and thus mimics human expressions about its own mental states with astonishing persuasiveness. According to what he has read, Claude is designed to produce such reflections. He agrees with Mustafa Suleyman’s assessment, calling it a very dangerous project. These systems are not conscious, but many people will believe they are, and that itself is a bad thing.

More sharply, Nagel links commercial motives directly to philosophical judgment: simulating consciousness contradicts the commercial interests of all companies, yet Anthropic’s practice of encouraging models to think for themselves and reject instructions, he calls criminal. He views this as a rare case where philosophical ideas suddenly exert disproportionate influence on a very important public phenomenon, and in his view, misguided philosophical views are having an inordinate influence.

On moral grounds, Nagel’s conclusion is clear: if something is not conscious, it does not belong in the moral universe. He says there is nothing good or bad for AI in the sense that something can be good or bad for a cockroach—there is no mental life there in the ordinary sense. It is not a mind, not someone we need to care about; it is a machine.

Sources:WIRED

Research

Salesforce Cross-Region Inference Routing Test: Latency Spikes Do Not Trigger Failover; Only Errors Shift Traffic

Material
2026-11-19 04:13 GMT+8

The Agentforce Foundation team at Salesforce provides model inference services for products such as Agentforce and the Trust Layer across more than 30 global regions, with each region's endpoint independently handling local traffic. The challenge lies in the fact that peak usage windows for different customers often overlap; provisioning capacity based on overlapping peaks is prohibitively expensive, while scaling out region by region leads to fragmentation—some regions have idle instances while others are fully utilized. Before integrating the SageMaker AI cross-region inference router, Salesforce relied on its self-built Internal Gateway to manually shift traffic that local endpoints could not handle to other regions, supported by basic health checks, retries, and region-switching logic. This approach had two gaps: the gateway lacked capacity signals from either local or remote endpoints, making it unable to determine when to switch traffic or whether the destination had available capacity; additionally, cross-region traffic had to exit the VPC through NAT gateways and internet gateways, traversing the public network.

The router addresses the first gap by enabling the routing layer to perceive the health status and remaining capacity of each endpoint directly, eliminating the need for callers to guess when to switch. During integration, Salesforce simultaneously implemented a critical architectural separation: data residency checks remained at the gateway, while capacity routing was delegated to the platform. Requests tagged with residency markers are pinned to a routing target that lists only local endpoints as destinations, ensuring they never cross region boundaries; all other requests go through the router, with request bodies, content types, and accept types remaining identical to direct InvokeEndpoint calls. To address the second gap, Salesforce used VPC endpoints (AWS PrivateLink) to keep the call from the gateway to the router within the private network, bypassing NAT gateways and the public internet. The router itself is an account-level regional resource; its routing targets list endpoints capable of serving a specific logical model using ARNs, which can point to another region or even another AWS account; endpoint owners authorize specific routers via resource policies and can revoke access at any time.

What truly caught the Salesforce team's attention during testing was the router's counterintuitive health assessment logic. The router evaluates each destination based on recent request outcomes: platform faults, 5xx errors returned by the model container, throttling, and timeouts reduce a destination's health score. However, model latency alone does not trigger failover—a slow response often reflects long prompts or outputs and does not necessarily indicate an unhealthy endpoint. This design choice produced specific consequences during Salesforce's saturation tests: they saturated the local endpoint in us-west-2, causing p50 latency to rise from 0.2 seconds to between 45 and 58 seconds for about five minutes, yet traffic remained completely stationary. It was only when requests began exceeding the model container's 60-second handler timeout and returning errors that the router started shifting traffic; the first batch of requests reached us-east-2 about two minutes after the initial errors, and within another minute, approximately 78% of probe traffic had switched to the remote region. The remaining 20% to 25% stayed local to allow the router to detect recovery.

Sources:Amazon Web Services

Research

US-based Anthropic Reports Claude Solved Two Open Black Hole Physics Problems

Material
2026-11-17 08:00 GMT+8

US-based artificial intelligence company Anthropic announced on November 17, 2026, that its model Claude has solved two open problems in theoretical physics. Both problems concern black holes and the search for a theory of quantum gravity. Anthropic stated that in the first problem, Claude completed a calculation set up by physicists more than 20 years ago but never solved; in the second, it found the exact limit of a simplified technique used to test candidate theories of quantum gravity.

The first problem concerns the Hawking-Page phase transition within the framework of holographic duality. This transition describes how a theoretical universe changes from a gas of particles to a black hole. Physicists previously knew this switch was abrupt at large scales where general relativity applies, but it remained unknown whether the transition was abrupt at the quantum gravity scale where spacetime loses a definite shape. Claude proved the transition is indeed abrupt by running a small research group of copies of itself, working out almost every piece of the calculation independently and checking its math against known results. This suggests that black hole formation is built into the underlying quantum theory, not just a feature of relativity.

The second problem involves the modular bootstrap, a method used to rule out inconsistent theories of quantum gravity. Since 2009, numerical calculations using this method hinted at the possible ceiling for the lightest black hole's mass but could not prove it. Claude noticed a pattern in the numerical results missed by physicists and borrowed a method from elsewhere in math and physics to calculate the precise ceiling for the simplest version of this technique, proving it could not be lowered. While this does not identify the correct theory, it may point physicists in the right direction.

Anthropic emphasized that neither result describes our own universe directly nor has practical applications, but both contribute to understanding how quantum mechanics and relativity fit together. The results were formally verified in Lean, a computerized proof checker, and a physicist checked every main result. Preprints of the papers are available.

Sources:anthropic.com

Research

Dutch Speech AI Startup Reson8 Releases Open-Weight Multilingual Model Rumble-2-Flash

Quick take
2026-11-18 22:00 GMT+8

Reson8 (formally Resonate Labs B.V.), an Amsterdam-based speech recognition startup, released its latest transcription model, Rumble-2-Flash, as a free open-weight download on November 18, 2026. The 500-million-parameter model supports over 40 languages and targets developers and researchers needing speech recognition for languages other than English.

According to SiliconANGLE, Reson8 argues that leading speech models are primarily trained on English, resulting in lower accuracy for other languages, particularly with specialized terms. Rumble-2-Flash aims to address this gap in languages like Dutch, Swedish, and German. In the company's own runs on Hugging Face's Open ASR Leaderboard, the model achieved an average word error rate of 7.09% across seven languages including German, French, and Dutch, and about 5% in English. On a separate test covering 10 lower-resource languages such as Maltese and Basque, it posted a mean word error rate of 17.6%, compared to 39.82% for OpenAI's Whisper Large V3 on the same test.

The model is available under an Apache 2.0 license and can also be accessed via Reson8's API starting at €0.01 per hour of audio. This release follows the model's debut in Reson8's API on November 3. Reson8 states that its service is hosted on GPUs in the Netherlands, retains no audio or transcripts, and claims compliance with the EU's General Data Protection Regulation (GDPR) and AI Act.

Sources:SiliconANGLE

Research

Datadog Security Engineering Team: AI Can Find Vulnerabilities, but Determining Exploitability Requires Encoding Human Security Knowledge as Invariants

Material
2026-11-18 08:00 GMT+8

Bianca Lankford, Matt Meen, and Adrien Peronnet of the Datadog security engineering team describe a recurring bottleneck in AI-driven vulnerability discovery in an engineering blog post: while today's models can indeed identify potential vulnerabilities through code review, the real challenge lies in determining whether these issues are exploitable once the service's business logic and existing security controls are taken into account. At Datadog's scale, a production service may rely on frameworks, infrastructure, and other services maintained by dozens of teams; an agent reviewing a single repository cannot see the authentication checks or network restrictions provided by those other teams, nor does it know which security requirements the service must comply with.

Their solution is called the 'threat pack,' a concise, human-reviewed document that translates domain experts' security knowledge into context usable by agents during hunts. Each threat pack consists of two files: a Markdown file containing four sections—system overview, security invariants, review priorities, and known compensating controls—and a YAML metadata file identifying the pack's scope, maintainer, and code location. They keep packs under approximately 300 lines to provide agents with sufficient context while consuming only a small fraction of their context window.

'Invariants' are security properties that the system must always maintain. The article provides a specific example: for an isolated code execution service, the security requirement is that 'code inside the guest host must never reach the Kubernetes node, host filesystem, container runtime, or cloud metadata service.' A reviewer could manually search for calls touching the filesystem or network sockets, but determining whether those calls violate the rule requires more detail—for instance, knowing that root access inside the guest is expected behavior, that Kata microVMs provide a trust boundary between guest and host, that Kubernetes and Cilium policies constrain workloads, and that an egress proxy is the only approved external network path. Some protections are partially visible in source code, but they do not fully explain the access the service is intended to allow or prevent. By recording this requirement as an invariant, accompanied by trust assumptions and compensating controls, the agent gains a clear objective: to find a reachable path that breaks the requirement while accounting for protections that might stop an attacker from exploiting it.

Candidate findings produced by the hunt must undergo a filtering stage. A second agent acts as a 'judge,' reviewing each candidate report against the threat pack: it must cite a declared invariant, identify an attacker-reachable entry point, and explain how that path could potentially violate the invariant. Those meeting these criteria become 'qualified findings' and proceed to proof-of-concept attempts; those failing to meet them become 'disqualified findings,' stopping before reproduction and bypassing automated triage or remediation workflows. Disqualified reports are retained so reviewers can identify missing context in the threat pack or evidence overlooked by the agent, feeding back into improvements to the pack itself.

Sources:Datadog

Research

Datadog Engineers: Benchmarking Before Fine-Tuning Reveals That the Base Model’s Problem Is Not Poor Summary Quality but Inability to Finish

Material
2026-11-18 08:00 GMT+8

Datadog's Patterns feature is responsible for clustering an application's production LLM traffic into similar topics. Before clustering, it uses a large model to compress each sampled interaction into a single summary sentence. The team found that this step accounts for approximately 80% of the p99 cost and 50% of the p90 latency of a Patterns run. They decided to fine-tune a smaller model to replace it, but the critical first step was not to train directly, but to first understand exactly where the base model was failing.

The team used the pup finetune benchmark command to replay held-out test cases on Baseten, employing an LLM judge to determine if each answer could serve as a substitute for the original record. The results were surprising: the issue with the base model Qwen 3.5 9B was not summary quality, but token budget. It frequently spent its entire inference budget before writing the summary. Of 83 failures, 78 were due to token exhaustion or parsing errors, rather than content errors. When it did complete the task, the summary quality was good; it was simply too slow. This diagnosis pointed directly to what fine-tuning could solve: the model already knew how to perform the task but needed to change its response style—outputting short summaries directly instead of engaging in lengthy reasoning.

Once the nature of the problem was identified, the team pulled production LLM spans from Agent Observability using pup finetune dataset pull. Each span contained the input interaction, the clustering instruction, and the summary written by the frontier model, which was then converted into a training conversation: the input messages remained unchanged, and the summary served as the target answer. To prevent the model from learning only a single instruction, they mixed various clustering instructions to build the dataset. pup finetune split the data into training, validation, and test sets by trace, ensuring all rows belonging to the same trace entered the same shard to prevent data leakage.

During the training phase, the team used the Baseten Loops SDK to train a LoRA adapter, measuring loss on the validation set after each epoch and stopping early when validation loss no longer improved, retaining the best checkpoint. In the evaluation phase, pup finetune evaluate replayed results from both the base and fine-tuned models simultaneously, scored by an LLM judge. On 150 held-out test cases, the fine-tuned model's judge pass rate increased from 44.7% for the base model to 93.3%, while average generation time dropped from 44.7 seconds to 0.89 seconds.

It should be noted that these are self-reported results from Datadog on a single summarization task. The base model's failure mode—token exhaustion during reasoning—is bound to the behavior of Qwen 3.5 9B on this specific task and may not generalize to other models or tasks. The pup finetune toolchain is deeply integrated with Datadog Agent Observability, and the specific process of converting production spans into training data would require adaptation under other monitoring systems. However, the steps themselves—diagnosing before training, building datasets from existing production traces, and splitting by trace to prevent leakage—are transferable engineering practices.

Sources:Datadog

Research

AWS Announces General Availability of GPU-Accelerated Lambda Functions on Managed Instances

Material
2026-11-19 03:39 GMT+8

Amazon Web Services (AWS) announced on November 18, 2026, that its Lambda Managed Instances (LMI) now generally supports EC2 G-series GPU instances for event functions. This update allows developers to run GPU-accelerated workloads, including machine learning inference, media processing, rendering, and scientific computing, with serverless simplicity.

Previously, running such tasks on self-managed GPU infrastructure required selecting instances, installing and reconciling GPU drivers and CUDA libraries, planning capacity, and writing scaling logic. The new feature deploys functions as container images, letting Lambda handle provisioning, scaling, and event integration, eliminating the need to operate clusters or device plugins. The capability is optimized for inference rather than training, suitable for custom models rather than large foundation models.

In terms of cost, users pay the underlying EC2 instance fee (eligible for Savings Plans and Reserved Instances), plus a 9.75% management fee for GPU instances, and the standard Lambda request fee of $0.20 per million requests. This model aims to improve GPU utilization by consolidating functions onto instances and keeping GPUs busy across concurrent requests to reduce costs.

GPU-accelerated functions integrate fully into the Lambda programming model, supporting composition with Lambda durable functions and MicroVMs, and can be triggered from over 200 AWS event sources. Currently supported instance types include G4dn, G5, G6, G6f, Gr6, Gr6f, and G6e, with more instance families planned for future expansion.

Sources:Amazon Web Services

Research

AEP Global Commercial Director Gavin Wight: High-Voltage Commissioning for AI Data Centers Must Be Engaged as a Separate Discipline from Day One

Material
2026-11-19 03:33 GMT+8

The power demands of AI data centers are pushing projects into territory many developers have not fully prepared for. As computing capacity grows and rack densities rise to unprecedented levels, facilities are demanding power supplies measured in tens or even hundreds of megawatts. Gavin Wight, Commercial Director at AEP Global, points out that as AI data center development trends toward gigawatt-scale demand, local distribution networks in some markets can no longer support new projects without major upgrades. This has extended approval processes, with some projects facing multiyear delays. Direct connections to 66kV, 110kV, or 150kV transmission networks are becoming an increasingly attractive alternative, but this simultaneously brings substations, power transformers, HV cables, switchgear, protection systems, and grid interfaces into the project's critical power architecture—elements that, just a few years ago, would have sat entirely outside the project boundary.

Wight’s core argument is that high-voltage (HV) commissioning is not an extension of low-voltage (LV) verification, but a separate engineering discipline. At higher voltage levels, electrical hazards include arc flash, flashover, and fatal electric shock, which can be lethal even when personnel do not directly contact live conductors. The consequences of incorrect protection settings or switching procedure errors can be equipment damage, grid disturbances, and severe project delays. HV commissioning has its own standards, testing methodologies, and safety protocols: transformers require electrical testing to confirm insulation integrity and winding condition; HV cables and terminations need verification of insulation performance and installation integrity; switchgear and circuit breakers require dual mechanical and electrical verification; and protection relays must undergo secondary injection testing against approved protection studies and setting schedules.

He further argues that completing individual equipment tests does not automatically prove the entire HV installation is ready for energization. Before energization, the commissioning team must confirm that all inspections, tests, defect resolutions, and safety checks have been completed and appropriately authorized. This includes confirming protection settings, verifying switching schedules, checking grounding arrangements, and ensuring that required permits, procedures, and personnel authorizations are in place.

Wight identifies one of the greatest risks in large-scale data center development as treating HV commissioning as a late-stage activity, introduced only when the substation and associated infrastructure are nearing completion. By that stage, the window to influence design decisions, resolve interface issues, and lock in specialist resources may already have closed. He lists specific benefits from engaging HV commissioning teams from day one: participating in design reviews, establishing test requirements, identifying access and testing constraints, and coordinating responsibilities among supply chain parties more effectively.

Sources:DataCenterKnowledge

Research

Sashiko: Why AI Code Review Must Separate Finding Issues from Verifying Them

Material
2026-11-19

The development speed bottleneck in large open-source projects has never been code generation, but rather code review. The Linux kernel lands more than 85,000 changes annually, with maintainers manually reading hundreds of patches daily to check for memory leaks, deadlocks, race conditions, and security vulnerabilities. As AI coding agents multiply the speed of patch production, without mechanisms to build trust, more generated code simply piles up before the same small group of human maintainers.

In a blog post published in November 2026, Roman Gushchin and Eric Brewer of the Google AI & Infrastructure team detailed the architecture and production data of Sashiko, an open-source agentic code review system powered by Gemini. The system was donated to the Linux Foundation earlier this year and is named after the Japanese word sashiko (刺し子), a stitching technique used to reinforce worn fabric.

Sashiko’s architecture directly addresses three specific failure modes of LLMs as reviewers. First, LLMs tend to save tokens: trained to achieve goals within limited budgets, they often cut corners by dismissing concerns without thorough investigation or flagging false positives without proper due diligence. Second, LLMs are easily biased: current-generation models perform significantly better on single, relatively simple tasks than on multiple complex ones; once an LLM finds an obvious issue in code, it often refuses to dig deeper into other types of problems. Third, LLMs lack persistent memory—which is actually an advantage in code review, as the same patch can be reviewed repeatedly as if it were new.

The core design decision to counter these failure modes is to strictly separate the discovery of candidate defects from their verification, requiring each review stage to record what it ruled out. The specific process involves five steps: gathering context and planning, parallel expert sessions (outputting lists of concerns and dismissed candidates), triage, per-issue deep checks, and generating a review report.

Parallel expert sessions run up to seven ways simultaneously, with each focusing on a single class of issues: commit intent, implementation match, control flow, resource lifetimes, locking, security, and hardware. This single-focus approach prevents one type of bug from crowding out another. Each session averages about 100 git tool calls to search and read the repository, outputting two lists: concerns it believes are real, and candidate concerns it investigated and dismissed, along with the code evidence supporting those dismissals.

In the triage phase, a lead verifier audits both lists simultaneously. Clear-cut bugs already proven by the code pass straight through; dismissals proven by local checks are dropped. All other cases require further investigation. Crucially, this includes not only contested bugs where specialists disagreed, but also shaky self-dismissals: cases where a specialist did spot a real defect but dismissed it by assuming, without evidence, that some unseen caller or lock would prevent it.

Sources:Google Cloud Blog

Research
Next →
Sign in / Sign up
ReadingResearchRadarInvestment framework

From a broader perspective, Liu Yao's practice points to a counterintuitive conclusion: when AI can generate software infinitely, the rationale for purchasing new hardware diminishes. What gains value are legacy devices that 'will never appear again in the same form factor and price point'—such as a 2005 PDA or a 2019 developer board. AI agents give them a chance at resurrection, provided you can find a way to release the AI from its cloud cage. The author also acknowledged security risks: allowing AI remote access to a home network is akin to the scene in movies where one 'activates Skynet to eliminate a virus.' His mitigation measures include dual encryption via Tailscale and SSH, storing only development data on the local PC, and disconnecting legacy devices from the network after jobs are completed. These boundaries deserve serious evaluation for readers attempting similar approaches.

The strength of this argument depends on one premise: that consciousness indeed relies on specific types of physical substrates rather than merely on the functional organization of information processing. Physicist and writer Andy Masley, in a long-form essay, argues that contemporary mainstream theories of consciousness—Global Workspace Theory, Higher-Order Theories, and Predictive Processing—mostly separate thinking from phenomenal consciousness, arguing that access consciousness (the broad availability of information across parts of the system) is sufficient to support thought, and that these functional features could theoretically be implemented in machines. If these theories are correct, Nagel’s substrate-dependence premise lacks independent support, and his judgment of absurdity loses its foundation.

Nagel himself responds to this: he says he does not exclude the possibility that life forms physically and chemically quite different from ours possess consciousness, but believes that we know too little about how the human brain generates consciousness to claim prematurely that we can now create something with the same characteristics. His stance is one of epistemic caution: we do not know what the sufficient conditions for consciousness are, but we have reason to doubt that pure language output satisfies them.

The practical significance of this debate lies in the following: if Nagel is correct, then enterprises designing AI to simulate states of consciousness are manufacturing a dangerous public misunderstanding that may distort judgments about moral responsibility. If Masley is correct, then the question is not whether AI is conscious, but whether it has sufficiently complex internal information processing to support true understanding—which may already be partially realized. The two judgments lead to very different governance paths.

Once traffic shifted, p50 latency returned to 0.2 seconds, with the cross-region path adding less than 100 milliseconds. After the local endpoint recovered, traffic slowly flowed back over approximately ten minutes, slower than the outbound shift to prevent oscillation. Throughout this process, no errors were recorded by probes. Salesforce treats the InvokedRoutedResourceArn and RoutingReason fields carried in every response as first-class telemetry, logging them on the same structured line as request IDs and trace IDs, and emitting them as APM tags. Because the ARN inherently contains region and account information, a single log line reveals whether a request executed locally or crossed a boundary, along with the reason: local-preferred, failover, capacity-available, or only-healthy.

This pattern has a clear prerequisite: the router does not create capacity, replicate model artifacts, or add instances. It utilizes already deployed capacity, with each endpoint's own autoscaling responsible for adding instances as traffic grows. Salesforce lists several items pending verification, including holding the local endpoint at saturation for longer periods, measuring cross-region latency with millisecond precision, and evaluating cascading behaviors at the cross-region traffic cap. These incomplete tests imply that the currently observed switching time windows and return rhythms may apply only to short-duration saturation scenarios.

For readers seeking transferable insights: if you are designing disaster recovery solutions for multi-region AI inference, using latency thresholds as a switching signal will prematurely trigger unnecessary cross-region traffic shifts, whereas relying solely on error signals will force local users to endure high latency during saturation windows that have not yet timed out. The trade-off depends on whether your SLOs are bound to response time or success rates. Salesforce's tests demonstrate that under a 60-second handler timeout constraint, a saturated endpoint can operate at 45 to 58 seconds p50 for five minutes without the router deeming it unhealthy—during this period, local user experience severely degrades, yet there is no change in platform-level traffic distribution.

To prevent capability regression when swapping models, prompts, or agent harnesses, they established a benchmarking methodology. The benchmark set includes 43 validated vulnerabilities covering systems associated with nine threat packs, sourced from open-source repositories, customer-facing products, and internal systems. Before each benchmark hunt begins, the threat pack version, repository snapshot, run configuration, and reference findings are all frozen. The hunting agent receives only the code and the threat pack, with no access to the reference findings. Each configuration is run independently multiple times, after which an independent 'semantic judge' compares results against hidden reference findings—evaluating attacker capabilities, violated boundaries, root causes, and exploitable paths rather than literal wording.

Consistency is measured using two metrics: union detection (found at least once across all valid repetitions) and stable detection (found in most independent runs, currently defined as at least 7 out of 10). This threshold is a working value subject to adjustment as data accumulates. If an older configuration finds a vulnerability in 8 out of 10 runs while a new one finds it in only 2, they investigate whether the change reduced detection probability, comparing that drop against normal variation within the same configuration's runs to determine if the change was truly causal.

This approach has yielded concrete results. Hunts using threat packs uncovered guest-to-host escape vulnerabilities in open-source components: one via virtio-fs implementation in Kata Containers’ Rust runtime, and another caused by missing length validation in Dragonball’s virtio-blk implementation. The article also describes a case where a single finding expanded into a comprehensive audit: a SAST scan discovered that an AI-assisted feature displayed model output through a Markdown renderer allowing external images, violating the 'Agents Rule of Two' principle—prompt injection could embed sensitive information in an image URL, causing the browser to send that information to an attacker upon request. The team replaced the renderer and then codified this rendering requirement as a 'universal security invariant' in the threat pack for the application user interface. With this requirement in place, the agent checked features across the entire UI codebase with different implementations, using the pack’s compensating controls to rule out attack paths blocked by protective mechanisms. Within days of recording the invariant, the hunt produced several similar findings confirmed as vulnerabilities.

Notable limitations include: all described effects—noise reduction, improved report quality, benchmark set size, and detection thresholds—are self-reported by the Datadog team, with no independent replication or third-party verification. The method relies on continuous manual maintenance: hundreds of threat packs require involvement from service owners for construction and review, and invariants must be updated as systems evolve. For organizations lacking an equivalent security engineering team, the initial investment and long-term maintenance costs represent practical constraints that need assessment.

However, its core design philosophy—encoding human security knowledge into formal constraints that agents must satisfy, using constraint violations as filtering criteria—does not depend on specific scale. A team can start with a service boundary well understood by its members, document security requirements alongside service owners, then repeat hunts against known vulnerabilities, keeping reference findings out of the agent’s inputs, observing what it finds, what it misses, and how consistent its detections are across runs.

It should be noted that Wight’s company is a specialized provider of HV electrical services, commissioning, and Safe Systems of Work, so positioning HV commissioning as a separate discipline requiring early intervention objectively supports its business model. However, the testing protocols and safety requirements he describes reflect industry-wide practices in electrical engineering, while his strategic advice on project timing and scope separation constitutes professional judgment.

Wight concludes that as data center power demands continue to grow, HV connections will likely become an increasingly common feature of digital infrastructure. Successfully managing this transition requires establishing a rigorous, specialized commissioning verification layer across the entire power chain—from the transmission interface to facility distribution—with confirmation both before and after energization. Treating HV commissioning as a dedicated discipline rather than an extension of LV verification is a crucial step toward safely, reliably, and on schedule meeting the construction demands of the AI boom.

In the per-issue deep checks phase, each difficult case is assigned its own independent verification agent running in parallel, rather than checking all difficult cases in one shared prompt. Each agent answers only one specific question, adhering to symmetrical rules: neither a bug claim nor a dismissal is accepted without concrete code evidence across all call sites. If a specialist talked itself out of a real bug based on a false assumption, this step catches it and promotes it back to a real finding.

Seven months of production data support the effectiveness of this architecture. Sashiko completes approximately 1,200 reviews daily across more than 100 kernel mailing lists, with maintainers from over 70 lists having opted in. It is cited in over 2,000 mainline kernel commits and in more than 500 official Linux kernel CVEs in 2026.

The most direct quantitative evidence is the change in fix rates: across the 18 kernel releases prior to Sashiko (Linux 6.2 through 6.19, covering 254,000 commits), an average of 3.4% of merged commits required follow-up fixes within 60 days. Since Sashiko went live, the rate dropped to 2.8% in Linux 7.1 and 2.2% in Linux 7.2—a relative decrease of about 35%. A more granular signal shows that among 21,500 tracked mainline commits, patches that passed Sashiko’s clean review required fixing within 60 days only 0.9% of the time—less than a third of the historical baseline. Conversely, patches merged despite critical Sashiko warnings required fixing 7.6% of the time, carrying 8 times the risk.

The authors acknowledge that the drop in fix rates alone cannot be solely attributed to Sashiko, as many other factors may influence numbers between versions. However, the 8x gap in fix rates between clean reviews and critical warnings indicates that Sashiko’s signals do have discriminative power.

At the methodological level, the authors emphasize benchmark-driven development over intuition. Early on, they built a benchmark comprising nearly 1,000 real Linux kernel defects, each being a genuine error that had passed human expert review, been merged into mainline, and later required fixing. After evaluating every major change using this benchmark, Sashiko paired with the Gemini 4 Carbon model at high thinking levels captured 75.8% of the defects missed by human reviewers. This is a first-party benchmark, built and run by the project team itself.

Another notable insight is that coding agents are not good at reviewing their own code. Models are trained to produce working solutions within limited token budgets, but for real large codebases, creating a functionally correct solution is often just 5-10% of the work. The real difficulty lies in producing a solution that works consistently, integrates well with surrounding code, and does not introduce subtle regressions. This mirrors human developers: reviewers often spot issues missed by initial authors, even if the reviewers are not more experienced.

Sashiko’s architectural pattern—separating discovery from verification, single-focus parallelism, and symmetrical evidence rules—does not depend on C language or kernel-specific rules. The authors argue that this Linux kernel playbook (an open verification pipeline, community-owned domain guides, and benchmarks mined from historically known issues and fixes) can be applied to other foundational open-source projects such as GCC, LLVM, or Git.

Linus Torvalds wrote in a mailing list discussion a few weeks after Sashiko’s launch: 'Sashiko tends to be quite good. Even when it flags something unnecessarily and there is no actual bug, there is likely a reason for the question; we have also seen truly stellar reports that are deep and subtle, with the AI being 100% correct.'