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.
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.
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.
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.
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.
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.
When AI can illuminate billions of lines of code simultaneously, the change in security work is not that it has become faster, but that the nature of three key stages has entirely shifted. Cisco Chief Security Officer Anthony Grieco describes this transition using the metaphor of moving from a flashlight to a floodlight: In the past, an engineer would hold a flashlight to inspect a single component, leaving everything outside the beam in shadow; now, AI can illuminate the entire codebase at once, meaning that discovery, remediation, and operations each face a fundamentally different problem.
In the discovery stage, the bottleneck has disappeared. According to Grieco, they no longer need to decide what to prioritize for inspection. Over the past six months, more than 50 specialized engineers paired with AI to scan over 6.7 billion lines of code, covering Cisco’s product portfolio and third-party assets. The assessment has become continuous: static analysis, live testing, configuration reviews, and exploit simulations are each handled by dedicated AI agents, while engineers perform validation. Discovery is no longer the bottleneck—the implication being that the most scarce resource for security teams in the past, namely inspection capacity, is no longer scarce.
However, discovery ceasing to be a bottleneck does not mean remediation is no longer a bottleneck. Grieco reports that to turn visibility into action, Cisco redirected approximately 1,500 engineers to fix bugs, delivering nearly 4,000 fixes in their 2026 security hardening releases. He specifically highlights one change: the floodlight-style visibility helps them fix entire classes of defects rather than individual instances, where one fix accomplishes the work of many. This means the unit of measurement for remediation has changed, but the work itself still requires human verification and release, which is why remediation has become a company-wide mission involving 1,500 engineers.
The third change lies in operations. Grieco states that with this new capability, security has become an automated rhythm: continuous assessment, fixed release cadences, and dedicated engineering teams focused on hardening. He clearly distinguishes between one-time cleanup and ongoing operational transformation, arguing that the latter is the harder work required by this moment.
All these figures come from Cisco’s own report. The numbers—6.7 billion lines, 4,000 fixes, and 1,500 engineers—are not independently verified. Grieco also acknowledges that this is not a scorecard, a confession, or a finish line, but merely an honest measure of vulnerabilities hidden within code. Another attribution point to note: Cisco President and Chief Product Officer Jeetu Patel publicly stated that he expects approximately 70% of their code to be AI-assisted by next year, but this is a projection rather than an achieved result. An example cited in the text, where a security product was reduced from approximately 8 million lines to under 1.5 million, similarly lacks independent confirmation.
Many enterprises face an apparently unsolvable conflict in their network architecture: the network team owns all VPCs and subnets, while application teams can only use shared subnets; simultaneously, all cross-VPC traffic must pass through a central firewall for inspection. When AI agents need to call internal private APIs or MCP servers via AgentCore Gateway, both requirements apply at once—the Gateway needs network entry points to reach backends, but those entry points cannot bypass the firewall.
AgentCore Gateway accesses private targets through VPC Lattice resource gateways, offering two modes: Managed mode, where AgentCore creates the resource gateway in the Gateway account (suitable when the Gateway account can own subnets); and Self-managed mode, where the resource gateway is placed in subnets with direct access to the backend (suitable when centralized inspection between the Gateway and tools is not required). Neither mode satisfies both constraints simultaneously. AWS’s proposed solution is a variant of self-managed mode: the network account creates and owns the resource gateway, places it in a dedicated VPC whose subnets are not shared with any account and contain no backends, but routes point to the Transit Gateway, ensuring every request and response traverses the inspection VPC.
The key mechanism enabling this solution lies in how VPC Lattice delivers connections. When creating a Gateway target, AgentCore associates the shared resource configuration with its own VPC Lattice service network. VPC Lattice then delivers connections from that service network to the network interfaces of the resource gateway. This hop is operated by AWS; from the resource gateway’s Elastic Network Interface (ENI) onward, routing and firewall rules take over subsequent paths. This means the AgentCore account does not need to create a Transit Gateway attachment in its own VPC, nor does it need to own any subnets.
This pattern has three explicit limitations. First, no payload inspection: Traffic between the Gateway and the Application Load Balancer (ALB) is end-to-end TLS encrypted; the firewall sees only flow metadata and TLS Server Name Indication (SNI), not the request content. Payload inspection relies on logs from the Gateway, AWS WAF, and ALB. Second, some paths bypass the firewall: The link from the agent to the interface endpoint, the link from the Gateway to the resource gateway, and token requests made by AgentCore to identity providers do not traverse the central firewall. Third, the tool cannot identify end-user identity: When using client credentials authorization, every call reaching the tool carries the Gateway’s client identity. Tracing a call to a specific caller requires examining inbound JWT claims in the Gateway application logs.
For validation, AWS demonstrated a clever test: In the firewall rules, a rule dropping response-direction traffic (drop tcp $TOOL_NET 443 -> $RGW_NET any) was added before the rule allowing request-direction traffic. If responses indeed traversed the firewall, tool calls would hang until timeout, and the firewall logs would record drop events in the to_client direction. Removing the rule restored calls, proving that the response direction does traverse the firewall.
Research organization Epoch AI released data insights on November 18, 2026, estimating that the agentic inference capacity of AI chips sold globally grew 4.6 times between Q2 2025 and Q2 2026. This rate is nearly double the 2.6 times growth observed in peak 8-bit computing power over the same period.
The analysis uses Epoch AI’s Inference Performance Index (IPI), which measures capacity based on fixed agentic workloads with long cached contexts, accounting for memory, inter-chip communication, and lower-precision computation. By applying these scores to their AI Chip Sales dataset, the researchers found that inference capacity per unit of peak compute rose by approximately 77% over the year.
This divergence is attributed to “hardware–model co-design,” where improvements beyond proportional increases in arithmetic throughput—such as larger scale-up domains and optimized architectures—allow new chips to handle agentic tasks more efficiently than raw FLOPS would suggest. Blackwell and Blackwell Ultra chips accounted for roughly 73% of total agentic inference capacity by Q2 2026, compared to 50% of total peak 8-bit computing power.
US data intelligence company Databricks announced on November 18, 2026, that its AI assistant Genie is now Generally Available in Microsoft Teams, alongside the launch of the Azure Databricks Genie plugin for Microsoft Copilot Cowork and Chat. This move aims to bring governed enterprise data context directly into the productivity tools employees already use.
In Microsoft Teams, users can send direct messages to the Databricks Genie app or @mention it in channels and group chats to get governed insights without leaving the collaboration environment. For example, a sales manager can ask, "Which open leads over $100K haven't had a follow-up this week?" Genie replies in the thread with matching leads, latest activity, and source links, eliminating the need to manually pull pipeline reports or cross-check CRMs.
The new Azure Databricks Genie plugin allows Microsoft Copilot Cowork and Chat to delegate work to Genie One. Instead of Copilot searching for correct answers on its own, the plugin leverages Genie Ontology to combine explicitly defined business semantics (such as how finance defines net retention) with context learned from everyday work, ensuring answers are grounded in certified definitions and metric views. All access is enforced by Unity Catalog permissions, preventing sensitive data from reaching unauthorized personnel.
Additionally, Genie One is now integrated into the Azure Databricks Excel Add-in, allowing analysts to ask questions in plain English and get answers from governed data with citations showing where numbers came from. These capabilities address the problem of generic AI assistants being unable to distinguish certified revenue tables or understand specific business definitions, reducing low adoption and lack of trust caused by inconsistent outcomes.
The German Federal Court of Justice (Bundesgerichtshof, BGH) clarified in a ruling dated October 13, 2026, that lawyers must perform substantive content reviews and assume full responsibility when using artificial intelligence (AI) to draft legal documents. If a document is primarily generated by AI without effective human oversight, courts may deem it non-compliant with formal requirements, rendering the appeal invalid.
The decision stems from a criminal appeal against a verdict by the Kaiserslautern District Court (Case No.: 3 StR 350/26). Under Section 345(2) of the Code of Criminal Procedure, valid grounds for appeal require the defense attorney's 'shaping participation' in the drafting process. The BGH's Third Criminal Senate stated that if an appeal brief is created using AI without significant content control by the lawyer, this shaping participation may be considered missing.
In the specific case, judges noted numerous generic, standardized passages in the appeal brief that had little connection to the facts established in the original trial. For instance, the text abstractly discussed possibilities for withdrawing from attempted crimes but failed to address the district court's finding that the defendant could no longer influence the victim after fleeing into a warehouse where police were already alerted. Although the BGH determined these flaws did not entirely negate the lawyer's involvement—thus rejecting the appeal on merits rather than procedural inadmissibility—the case underscores strict review obligations.
This ruling signals to the legal profession that uncritical reliance on AI-generated text poses high procedural risks. Courts are empowered to reject such automated inputs and refuse to reopen cases on formal grounds. This aligns with a broader trend of stricter judicial scrutiny regarding technology misuse; previously, the Berlin Higher Regional Court also reprimanded lawyers for submitting documents containing AI hallucinations.
Bankruptcy services data company Stretto and AWS partner CI&T co-authored an article on the Amazon Machine Learning Blog detailing their production deployment experience with their voice AI agent, Tara. Tara is used to answer calls from individuals seeking bankruptcy advice on the Bankruptcy.com website, conducting structured pre-bankruptcy interviews. A specific engineering constraint shaped the core of the technical narrative: the full attorney-designed interview takes 15 to 20 minutes, which exceeds the maximum duration of a single streaming session on Amazon Nova 2 Sonic. Rather than treating this limitation as a defect to be avoided, the team viewed it as a design parameter, leading to the development of a session continuation pattern.
The mechanism of the session continuation pattern works as follows: a voice bridging layer continuously tracks how long the bidirectional audio stream between the caller and Nova 2 Sonic has been active. Approaching the limit, it opens a new stream using the same system prompt and tool configuration, feeding in the conversation history thus far as text. Once Tara completes her current response, the bridging layer switches the caller's audio to the new stream while closing the old one. To the caller, the conversation seamlessly continues at the response boundary, without them perceiving that a session switch occurred underneath.
The portability of this pattern lies in its independence from model improvements; it handles constraints at the orchestration layer. Any team building a telephone agent using streaming voice models will encounter the conflict between single-session duration limits and real-world conversation lengths. The timing of the switch described in the article—after the model finishes its current response—is a key design choice: switching mid-response would cause audio breaks for the caller, while switching before the response begins might mean the model has not yet output a complete semantic unit.
Before deploying Tara to production, the team dedicated an entire week specifically to validating voice quality, covering caller emotional states (calm, nervous, hesitant, frustrated), baseline audio latency, interruption handling, and emotional tone adaptation. This validation report served as a go/no-go gate for proceeding with integration. This practice itself serves as a recommendation: in voice AI deployments involving sensitive financial information, validate conversational naturalness and emotional adaptability first, then write integration code, rather than doing so in reverse.
Boundaries to retain: all performance figures in the article are self-reported by Stretto—approximately 96% accuracy in structured field extraction, average call completion time of about 8 minutes, a 95% reduction in per-minute voice costs compared to previous solutions, and a 20% increase in lead conversion rates compared to web forms. These figures have not been independently replicated, and the 95% cost reduction is based on Amazon Bedrock on-demand pricing in the us-east-1 region as of April 2026. The behavior of the session continuation pattern under adversarial conditions (such as callers interrupting at the switch boundary, or emotional states being lost during text history transmission) was not detailed in the article.
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.'
Nevertheless, the practical value of this blog post for readers lies not in verifying Cisco’s specific numbers, but in describing a transferable structural change in workflow: when visibility is no longer the constraint, the core challenge for security teams shifts from determining what to check to how to turn discoveries into systematic remediation and a sustained operational rhythm. Grieco’s judgment is that every software company will eventually face this reality, and traditional security practices cannot keep up. This is an argument about how the nature of work reorganizes as tool capabilities evolve, not a promotional piece on how powerful AI is.
The testing scope was limited to the us-east-1 Region, AWS Network Firewall, and no source NAT. Source NAT, multi-Region deployment, private identity providers, and OpenAPI limitations are discussed in other documentation within the companion repository. AWS recommends running the full set of fourteen validation checks in a non-production copy before adopting the pattern in production environments.
Danya Gordin, Chief AI Architect at Stretto, and Marcelo Wzorek, Executive Manager at CI&T, are quoted in the article regarding project outcomes. The article was published by the AWS Machine Learning Blog; AWS holds a commercial interest relationship as the provider of the model and cloud infrastructure. This attribution boundary should be retained when citing its performance claims.