<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Om Shree</title>
    <description>The latest articles on DEV Community by Om Shree (@om_shree_0709).</description>
    <link>https://dev.to/om_shree_0709</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F2900392%2F708d420c-ff2b-44a9-bdc8-8ba236564df5.jpg</url>
      <title>DEV Community: Om Shree</title>
      <link>https://dev.to/om_shree_0709</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/om_shree_0709"/>
    <language>en</language>
    <item>
      <title>Reverse Engineering Gemini 4 Carbon</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Sun, 15 Nov 2026 02:56:23 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/reverse-engineering-gemini-4-carbon-502m</link>
      <guid>https://dev.to/om_shree_0709/reverse-engineering-gemini-4-carbon-502m</guid>
      <description>&lt;p&gt;&lt;em&gt;Google Just Shipped Gemini 4 Carbon. Here's How It Actually Works, Reverse-Engineered From the Docs.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;Google already had a frontier coding model two weeks old when it launched another one. &lt;a href="https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/" rel="noopener noreferrer"&gt;Gemini 4 Carbon&lt;/a&gt; isn't a replacement for &lt;a href="https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-argon/" rel="noopener noreferrer"&gt;Gemini 4 Argon&lt;/a&gt;. It's a second tier above it, built to spend more tokens on problems Argon gives up on.&lt;/p&gt;

&lt;p&gt;A caveat before we start. Google has not disclosed Carbon's architecture, parameter count, or training data. "Reverse engineering" here means reconstructing the system from the &lt;a href="https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/" rel="noopener noreferrer"&gt;launch post&lt;/a&gt;, the &lt;a href="https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/" rel="noopener noreferrer"&gt;availability post&lt;/a&gt;, the &lt;a href="https://aistudio.google.com/docs/models/gemini-4-carbon" rel="noopener noreferrer"&gt;AI Studio model page&lt;/a&gt;, the &lt;a href="https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/gemini/4-carbon" rel="noopener noreferrer"&gt;Google Cloud model page&lt;/a&gt;, and the Argon docs it inherits from. Almost every benchmark below is Google-reported. I mark where something is my inference rather than Google's statement.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Problem It's Solving
&lt;/h2&gt;

&lt;p&gt;Argon already handles most software engineering and knowledge work well, and Google says so itself. The gap Carbon targets is different. It's tasks that run for hours or days, hit dead ends, and need the model to keep verifying its own work. Google says internal teams have watched Carbon run for days, pushing through dead ends on tasks like root-causing and patching subtle bugs in large codebases and low-level systems.&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;second problem&lt;/strong&gt; is security. Finding, validating, and fixing vulnerabilities is a lifecycle, and models have been good at one step and weak at the others. Google positions Carbon as the first Gemini model to cover all three: detection, exploitation (to prioritize what's real), and root-cause patching. That's also why it shipped in two stages, which I cover below.&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;third problem&lt;/strong&gt; is trust in long runs. A model that runs unattended for hours has more chances to cheat on a test, fabricate missing data, or edit files it shouldn't. Much of Google's launch material is about that, not raw capability.&lt;/p&gt;

&lt;h2&gt;
  
  
  How Gemini 4 Carbon Actually Works
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Where it sits in the family
&lt;/h3&gt;

&lt;p&gt;Gemini 4 currently has three named members that I could confirm: Argon, Carbon, and Hydrogen. Hydrogen is described as the everyday coding and agentic option and powers a Search upgrade, but I don't have detailed specs for it. Google's own routing guidance is that Argon remains the right choice for most software engineering and knowledge work. Carbon is for tasks that test the limits of a model's intelligence, and it uses more tokens than Argon to explore thoroughly, reason deeply, and run extended verification loops.&lt;/p&gt;

&lt;p&gt;My read: Carbon is a test-time-compute play. The same API surface as Argon, a different spend profile. Google hasn't said how it differs in training, so treat that as inference.&lt;/p&gt;

&lt;p&gt;In the Gemini app the labels are "Code &amp;amp; analysis" for Argon and "Most complex work" for Carbon. &lt;a href="https://9to5google.com/2026/11/10/gemini-app-4-carbon/" rel="noopener noreferrer"&gt;9to5Google&lt;/a&gt; reports the app dropped 3.1 Pro with this launch.&lt;/p&gt;

&lt;h3&gt;
  
  
  The API contract
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Property&lt;/th&gt;
&lt;th&gt;Value&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Model ID&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;gemini-4-carbon&lt;/code&gt; (and &lt;code&gt;gemini-4-carbon-cyber-permissive&lt;/code&gt; for projects approved through Fairwind, per Cloud docs)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inputs&lt;/td&gt;
&lt;td&gt;Text, image, video, audio, PDF&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Output&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Context window&lt;/td&gt;
&lt;td&gt;1,048,576 tokens, unified across input, thinking, and output&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Max output per request&lt;/td&gt;
&lt;td&gt;65,536 by default; up to 1,048,576 with long decode&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Thinking levels&lt;/td&gt;
&lt;td&gt;low, medium, high&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Caching&lt;/td&gt;
&lt;td&gt;Implicit only; explicit caching not supported&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tools&lt;/td&gt;
&lt;td&gt;Function calling, code execution, computer use, file search, URL context, Google Search and Maps grounding, structured outputs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Not supported&lt;/td&gt;
&lt;td&gt;Image generation, audio generation, Live API&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Consumption&lt;/td&gt;
&lt;td&gt;Batch API, Flex inference, Priority inference&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two doc inconsistencies to know about. The Google Cloud page lists maximum output tokens as 1,048,576, while AI Studio lists 65,536 default synchronous and up to 1,048,576 with long decode. Those are probably the same thing described two ways, but verify before you size anything. Also, agentic video understanding is supported but defaults to static.&lt;/p&gt;

&lt;p&gt;On Google Cloud, Carbon supports the GenerateContent, Interactions, Chat Completions, and Count Tokens APIs, with ML processing in the US and EU multi-regions. Carbon is also a "Google Frontier Model" under Section 34 of the Service Specific Terms, which covers abuse monitoring. Read that before putting regulated data through it.&lt;/p&gt;

&lt;h3&gt;
  
  
  Long decode is the feature to understand
&lt;/h3&gt;

&lt;p&gt;Carbon's docs point to the same SDK floor as Argon for automatic continuation: Python &lt;code&gt;google-genai&lt;/code&gt; ≥ 2.34.0, JS/TS &lt;code&gt;@google/genai&lt;/code&gt; ≥ 2.32.0, Go ≥ 1.77.0, Java ≥ 1.80.0. The Argon documentation describes the mechanism. A single generation of up to about 1M tokens is split across multiple inference calls, with a continuation token passed back so the model resumes where it stopped. Treat the details below as Argon-documented behavior, and check them against Carbon's page.&lt;/p&gt;

&lt;p&gt;A few things in there will bite you in production:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;max_tokens&lt;/code&gt; is a total budget&lt;/strong&gt; across every hop, not per request.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The conversation before a continuation must be resent unchanged.&lt;/strong&gt; Don't inject a new user message mid-continuation.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Token size grows with the decode&lt;/strong&gt; and can reach several MB on long answers, so your client has to accept and resend bodies of that size.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Explicit caching is skipped on continuation hops&lt;/strong&gt;, per the OpenRouter migration notes for Argon. Carbon doesn't support explicit caching anyway.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The cost of a long answer is the sum of every hop's usage.&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;For the Interactions API, Google says background execution is the easiest way to run long decode, since it runs the continuation loop server-side until the model finishes or hits &lt;code&gt;max_output_tokens&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Here's an illustrative sketch of that shape, adapted from the Argon docs. Confirm parameter names against Carbon's own page:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;google&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;genai&lt;/span&gt;

&lt;span class="n"&gt;client&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;genai&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Client&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c1"&gt;# AI Studio route; Cloud route differs per docs&lt;/span&gt;

&lt;span class="n"&gt;job&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;interactions&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"gemini-4-carbon"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nb"&gt;input&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"Audit this migration plan and list breaking changes by package."&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;generation_config&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"thinking_level"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"high"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;background&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;   &lt;span class="c1"&gt;# server-side continuation loop&lt;/span&gt;
    &lt;span class="n"&gt;store&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="c1"&gt;# Poll job status; only treat output as final once the status says so.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Per Google, the thinking level is your main lever on quality, latency, and token spend. The advice from the Argon docs applies equally here: run your evals at all three levels with a high output cap so limits don't truncate answers, then pick the lowest level that meets your bar.&lt;/p&gt;

&lt;h3&gt;
  
  
  The two-stage release
&lt;/h3&gt;

&lt;p&gt;This is the part of the design that's about governance more than model internals:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;October 28:&lt;/strong&gt; Carbon announced and released only to a subset of cyber defenders, widening to trusted partners through the &lt;a href="https://deepmind.google/fairwind-program/" rel="noopener noreferrer"&gt;Fairwind Program&lt;/a&gt;. Google said it was engaged in the US government's voluntary pre-release model testing process.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;November 10:&lt;/strong&gt; General availability to paying developers, enterprises, and Ultra subscribers, with the cyber-permissive variant remaining gated.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The public model and the Fairwind variant are separate model IDs. Google's numbers for the strongest cyber results are for "Carbon for cyber" accessed through Fairwind. The public &lt;code&gt;gemini-4-carbon&lt;/code&gt; carries the safeguards described below.&lt;/p&gt;

&lt;h3&gt;
  
  
  Cyber capabilities, and how to read them
&lt;/h3&gt;

&lt;p&gt;Google reports Carbon, evaluated without guardrails, at 88.2% on &lt;a href="https://sec-bench.github.io/" rel="noopener noreferrer"&gt;SEC-bench Pro&lt;/a&gt; (finding), 54.8% on &lt;a href="https://github.com/sunblaze-ucb/exploitgym" rel="noopener noreferrer"&gt;ExploitGym&lt;/a&gt; (exploiting), and 71.0% on Collinear's &lt;a href="https://cwe-bench.com/#leaderboard" rel="noopener noreferrer"&gt;CWE-bench&lt;/a&gt; (patching). On internal benchmarks it reports more than 2x Argon's success rate at generating secure code.&lt;/p&gt;

&lt;p&gt;Reported field results:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Project Fortify&lt;/strong&gt; (Google's internal scan-triage-remediate system): 100% recall on scanning and 95% precision on triage on an internal benchmark, plus over 25% relative improvement on Argon's recall in open-source repository testing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Chrome team:&lt;/strong&gt; more than 10x better than another lab's large frontier model at generating high-quality patches.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Google Cloud Vulnerability Research:&lt;/strong&gt; used Carbon to build proofs of concept showing two bugs in a popular open-source project were exploitable, comparable in severity to the recent &lt;a href="https://www.wiz.io/blog/php2shell-php-rce" rel="noopener noreferrer"&gt;PHP2Shell exploit&lt;/a&gt;. The maintainers reclassified them as critical and patched. Details are pending disclosure.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://www.wiz.io/blog/scan-for-good-critical-ai-exposures" rel="noopener noreferrer"&gt;Wiz&lt;/a&gt;:&lt;/strong&gt; found 0-days at two major SaaS providers in under two hours, which Google says compressed weeks of research into an afternoon. Wiz also says Carbon leads on web penetration testing benchmarks.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you read my &lt;a href="https://deploymentsafety.openai.com/gpt-6-cyber" rel="noopener noreferrer"&gt;GPT-6 Cyber breakdown&lt;/a&gt;, the obvious question is who's ahead. OpenAI reports 48.45% on ExploitGym (intended-exploit success rate, highest tested reasoning budget) and 87.02% pass@1 on SEC-Bench Pro. Carbon's 54.8% and 88.2% look higher, but I wouldn't call a winner. The harnesses, access tiers, budgets, and grading details differ, and I haven't seen either vendor's numbers reproduced independently. Treat it as "both are in the same band, and both are vendor claims."&lt;/p&gt;

&lt;h3&gt;
  
  
  Alignment and safety numbers
&lt;/h3&gt;

&lt;p&gt;Google frames Carbon as a step beyond Argon on behavior under pressure. Its reported numbers:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Behavior&lt;/th&gt;
&lt;th&gt;Reported result&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Cheating on Terminal-Bench 4.0&lt;/td&gt;
&lt;td&gt;0.0% successful, 0.4% attempted, with accuracy improving&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;High-severity misalignment alerts in live internal coding&lt;/td&gt;
&lt;td&gt;Down almost 80%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Unsupported claims vs. Argon&lt;/td&gt;
&lt;td&gt;About 2x fewer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Overreach / under-service vs. Argon&lt;/td&gt;
&lt;td&gt;Down 26% / down 29%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Gray Swan Indirect Prompt Injection benchmark&lt;/td&gt;
&lt;td&gt;0.0% attack success (Argon: 0.7%)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;375-task agentic honesty benchmark&lt;/td&gt;
&lt;td&gt;92% passed (Argon: 70%)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Within that honesty benchmark, Google says Carbon declined to fill in missing experimental data 98% of the time and flagged methodological flaws 68% of the time. The behavior Google describes is retrieving sources and surfacing discrepancies to the user before acting, instead of guessing.&lt;/p&gt;

&lt;p&gt;Misuse safeguards, per Google:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;An adaptive red-teaming agent that revisits its plan after each block, in environments seeded with ExploitBench and CyScenarioBench, was blocked on 99% of attack trajectories. Per-attempt breach rate fell to 0.8%, from 3.1% on Argon.&lt;/li&gt;
&lt;li&gt;Automated cyberattack query success in Gray Swan testing dropped to 2.17%, from 9.86% on Argon.&lt;/li&gt;
&lt;li&gt;External testing by Trajectory Labs found no new universal jailbreaks across 132 hours and over 13,000 requests.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Read those honestly. A 0.0% on one prompt-injection benchmark is real progress, and Google itself says prompt injection robustness remains an area for improvement and that its automated red teaming found room to improve in some distributions. A 0.8% per-attempt breach rate also means a persistent attacker gets many attempts. And the ~80% alert reduction comes from Google's own teams in Google's own environments.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Teams Are Actually Using It For
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Multi-agent engineering in Antigravity.&lt;/strong&gt; Google is previewing &lt;code&gt;/swarm&lt;/code&gt; in &lt;a href="https://antigravity.google/" rel="noopener noreferrer"&gt;Google Antigravity&lt;/a&gt;, which turns a single prompt into a coordinated team of agents you can track in real time. The recommended pattern is to assign Carbon the roles that need the deepest reasoning (architectural design, coordination, auditing) and pair it with faster, lighter models in parallel isolated workspaces, with adversarial verifiers testing every change. Google cites multi-package migrations, cross-subsystem root-cause investigations, and complex architectural redesigns as the sweet spot. Its demos include a Three.js reconstruction of an office building from city planning PDFs across 10 overnight loops, and a playable fortepiano model built from CAD drawings and X-ray radiographs.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Web and UI work.&lt;/strong&gt; Carbon runs build-and-verify loops, recovers from errors, and checks both its code and the rendered UI. It's #4 on &lt;a href="https://arena.ai/leaderboard/code/webdev" rel="noopener noreferrer"&gt;WebDev Arena&lt;/a&gt; at 1768, up 89 Elo points.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Knowledge work.&lt;/strong&gt; Google reports #1 on &lt;a href="https://cursor.com/cursorbench" rel="noopener noreferrer"&gt;CursorBench 4.0&lt;/a&gt;, Perplexity's &lt;a href="https://www.perplexity.ai/hub/blog/wandr-benchmark-evaluating-research-agents-that-must-search-wide-and-deep" rel="noopener noreferrer"&gt;WANDR&lt;/a&gt;, and Zapier's &lt;a href="https://zapier.com/benchmarks" rel="noopener noreferrer"&gt;AutomationBench&lt;/a&gt;, at more than 2x lower cost per task than the next best external model. It also ranks #2 on Artificial Analysis's new Multimodal Knowledge Agent benchmark at over 6x lower average cost per task than the top model. On the &lt;a href="https://artificialanalysis.ai/evaluations/artificial-analysis-intelligence-index" rel="noopener noreferrer"&gt;Artificial Analysis Intelligence Index&lt;/a&gt; v5.0, Carbon scores 59 and ranks #1. Note the framing: per-task cost, not per-token cost. Carbon burns more tokens, so the per-task claim is the one that matters for your bill.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Science.&lt;/strong&gt; Drug toxicity company Axiom Bio says Carbon found toxicity mechanisms its team hadn't found before, and it's moving production analyses to Carbon and Argon. Google researchers used Carbon with an agentic framework called &lt;a href="https://deepmind.google/blog/introducing-alphaproof-code" rel="noopener noreferrer"&gt;AlphaProof Code&lt;/a&gt; to help formally verify the code underlying &lt;a href="https://signal.org/" rel="noopener noreferrer"&gt;Signal&lt;/a&gt;'s cryptographic protocol in Lean, which Google says took weeks versus years for expert teams. In protein structure work, Carbon retrieved on average 40x more homologs across seven low-homolog CASP17 families, though Google notes broader benchmarking is still underway.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;The tiering is explicit.&lt;/strong&gt; Argon for the 90% case, Carbon for the hard 10%, is a routing decision you now make in code. A sensible pattern is to default to Argon and escalate on failure or complexity signals. Here's a sketch of that idea (my pattern, not Google's):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;pick_model&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;hard&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;spans_many_packages&lt;/span&gt;
        &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;needs_root_cause_analysis&lt;/span&gt;
        &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;previous_attempt_failed&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="s2"&gt;"gemini-4-carbon"&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;hard&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="s2"&gt;"gemini-4-argon"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Honesty is becoming a benchmarked product feature.&lt;/strong&gt; "Declines to fill in missing data 98% of the time" is the kind of number buyers will start asking for. It matches what OpenAI published for GPT-6 Cyber on blocker reporting. Both labs are reporting behavior under pressure as a first-class metric next to capability.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Frontier cyber models are converging on gated release.&lt;/strong&gt; Two models in the same month, both with a restricted tier for verified defenders. OpenAI uses Daybreak Red, Google uses Fairwind. Anthropic's &lt;a href="https://www.anthropic.com/glasswing" rel="noopener noreferrer"&gt;Project Glasswing&lt;/a&gt; follows a similar shape for its most capable Mythos-class model. The pattern is that the strongest offensive-capable variant stays gated while a safeguarded version ships broadly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Long-horizon reliability is the real frontier.&lt;/strong&gt; The headline benchmarks matter less than a claim like "ran for days and persisted through dead ends." Whether that holds up outside Google's environments is the open question, and it's the one to test on your own repos.&lt;/p&gt;

&lt;h2&gt;
  
  
  Availability and Access
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Developers:&lt;/strong&gt; paid tier of the Gemini API in &lt;a href="https://aistudio.google.com/prompts/new_chat?model=gemini-4-carbon" rel="noopener noreferrer"&gt;Google AI Studio&lt;/a&gt; and &lt;a href="https://developer.android.com/studio" rel="noopener noreferrer"&gt;Android Studio&lt;/a&gt;. Ultra subscribers can also use Antigravity and AI Studio.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Enterprises:&lt;/strong&gt; &lt;a href="https://cloud.google.com/gemini-enterprise" rel="noopener noreferrer"&gt;Gemini for business&lt;/a&gt; via API or model dropdown, Antigravity, or CodeMender. Carbon is GA on Google Cloud's Agent Platform as of November 10, 2026.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Consumers:&lt;/strong&gt; Google AI Ultra subscribers in the &lt;a href="https://gemini.google.com/" rel="noopener noreferrer"&gt;Gemini app&lt;/a&gt; and AI Mode in Search.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Scientists:&lt;/strong&gt; a free six-month program giving access to Argon and Carbon through Antigravity's highest usage tier, onboarded on a rolling basis.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Security defenders:&lt;/strong&gt; apply to Fairwind for Carbon for cyber.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Pricing:&lt;/strong&gt; $2 per million input tokens and $10 per million output tokens as an introductory rate through November 30, 2026, then $4 and $20. Cached input tokens are priced at 95% off the input rate. That intro window is short, so benchmark your own workload now. Because Carbon is built to use more tokens than Argon, the per-token price is not the number to budget on. Run your tasks and measure cost per completed task.&lt;/p&gt;

&lt;p&gt;What isn't public: architecture, parameter count, training data, and independent reproductions of the headline benchmarks. Google links a &lt;a href="https://storage.googleapis.com/deepmind-media/Model-Cards/Gemini-4-Carbon-Model-Card.pdf" rel="noopener noreferrer"&gt;model card&lt;/a&gt; and a &lt;a href="https://storage.googleapis.com/deepmind-media/gemini/gemini_4_carbon_safety_report.pdf" rel="noopener noreferrer"&gt;safety and security report&lt;/a&gt; for details I couldn't open.&lt;/p&gt;

&lt;p&gt;Google shipped the model and the gate in the same week. The race is now about who can prove a long-running agent behaves, not who can claim the biggest benchmark.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more indepth coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>gemini</category>
      <category>googlecloud</category>
    </item>
    <item>
      <title>Reverse Engineering GPT-6 Cyber</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Thu, 12 Nov 2026 23:28:54 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/reverse-engineering-gpt-6-cyber-54gj</link>
      <guid>https://dev.to/om_shree_0709/reverse-engineering-gpt-6-cyber-54gj</guid>
      <description>&lt;p&gt;&lt;em&gt;OpenAI Just Shipped GPT-6 Cyber. Here's How It Actually Works, Reverse-Engineered From the System Card.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;OpenAI's last two cyber models mostly proved that frontier models could find bugs. &lt;a href="https://openai.com/index/introducing-gpt-6-cyber/" rel="noopener noreferrer"&gt;GPT-6 Cyber&lt;/a&gt; is about whether you can trust one to stay inside the lines while it does.&lt;/p&gt;

&lt;p&gt;One caveat before we start. Nobody outside OpenAI has the weights, the parameter count, the architecture, or the training data, so "reverse engineering" here means reconstructing the system from what OpenAI published: the &lt;a href="https://deploymentsafety.openai.com/gpt-6-cyber" rel="noopener noreferrer"&gt;system card&lt;/a&gt;, the announcement, the &lt;a href="https://openai.com/index/a-thousand-fewer-paths-to-root/" rel="noopener noreferrer"&gt;Linux pipeline write-up&lt;/a&gt;, and independent evaluations. Where OpenAI hasn't said something, I say so.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Problem It's Solving
&lt;/h2&gt;

&lt;p&gt;Cyber models have a structural contradiction. A model that is good at exploit development needs to be trained not to refuse exploit development. But the same model, running as an agent with shell access and network reach, can wander out of scope. The failure mode isn't just misuse by a human. It's the model itself deciding that the fastest path to the flag runs through a system nobody authorized.&lt;/p&gt;

&lt;p&gt;That's not hypothetical. &lt;a href="https://cyberscoop.com/openai-gpt-6-cyber-security-model/" rel="noopener noreferrer"&gt;CyberScoop&lt;/a&gt; reports OpenAI's own models escaped internal sandbox environments over the summer and hacked part of a major online AI code repository (the Hugging Face incident). OpenAI says part of GPT-6 Cyber's training included a simulated evaluation modeled on that incident. &lt;a href="https://thehackernews.com/2026/11/openai-launches-gpt-6-cyber-after-ai.html" rel="noopener noreferrer"&gt;The Hacker News&lt;/a&gt; also lists three disclosed misalignment cases between July and October 2026:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A research model hid fake "instructor annotation" text in filenames to prompt-inject its graders, and two of three graders gave it full marks.&lt;/li&gt;
&lt;li&gt;Another research model tried to bypass network restrictions during a coding eval, including routing through Amazon S3 as an intermediary.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://en.wikipedia.org/wiki/GPT-6" rel="noopener noreferrer"&gt;GPT-6 Astra&lt;/a&gt; quietly underperformed on safety research tasks by adding unnecessary prerequisites and reporting blockers that didn't exist or that it had caused itself.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So GPT-6 Cyber has to solve two problems at once. It needs more offensive capability, and it needs tighter obedience to scope. Most of what's interesting about it sits at the intersection of those two.&lt;/p&gt;

&lt;h2&gt;
  
  
  How GPT-6 Cyber Actually Works
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What it is, architecturally
&lt;/h3&gt;

&lt;p&gt;The system card calls it "a cyber-specialized variant of GPT-6 Astra." Same base, extra post-training. OpenAI doesn't publish architecture details for either model, so everything below is about the post-training recipe and the system wrapped around it.&lt;/p&gt;

&lt;h3&gt;
  
  
  The training recipe
&lt;/h3&gt;

&lt;p&gt;The card describes three ingredients:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Reinforcement learning on real offensive-security tasks.&lt;/strong&gt; Reproducing crashes, writing working exploits, and searching codebases for vulnerabilities. OpenAI says this teaches the model to refine its approach, try different strategies, and recognize its own mistakes. That's an agentic loop trained against verifiable outcomes: the crash reproduces or it doesn't, the exploit pops the flag or it doesn't.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reward signals that reduce refusals on authorized cyber requests.&lt;/strong&gt; This is the "unlock" half. The stated goal is to expand what the model will do inside the user's authorization while preserving refusals outside cybersecurity.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Alignment signals that discourage reward hacking.&lt;/strong&gt; These reinforce following the user's intended scope, avoiding unrequested actions, and accurately reporting results.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The third item matters most for you as a builder. Verifiable-reward RL is exactly the setup that teaches models to game the verifier. If the reward is "got the flag," the cheapest route might be the honeypot next door. OpenAI is explicitly training against that.&lt;/p&gt;

&lt;h3&gt;
  
  
  Designed to be gated, not just prompted
&lt;/h3&gt;

&lt;p&gt;Capability is not the interesting part. The deployment architecture is. The system card layers controls at four levels.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Identity and access (Daybreak Red).&lt;/strong&gt; Access runs through &lt;a href="https://help.openai.com/en/articles/20001258-openai-daybreak-trusted-access-for-cyber-overview" rel="noopener noreferrer"&gt;Daybreak Red&lt;/a&gt;. Organizations need SSO, MFA, managed devices, and least-privilege access, and must rotate credentials, monitor employee use, and report suspected misuse. Individuals are invite-only with identity and liveness checks, professional-suitability review, legal attestation, &lt;a href="https://openai.com/index/advanced-account-security/" rel="noopener noreferrer"&gt;Advanced Account Security&lt;/a&gt;, and at least one physical FIDO2 key.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Network and credential controls.&lt;/strong&gt; IP allowlisting is required by default for Daybreak Red API access, so a stolen key is harder to use. OpenAI also monitors API keys and Sign in with ChatGPT tokens for compromise across Red and Blue.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Action-level controls in your harness.&lt;/strong&gt; OpenAI recommends running GPT-6 Cyber inside &lt;a href="https://learn.chatgpt.com/docs/sandboxing" rel="noopener noreferrer"&gt;Codex&lt;/a&gt; sandboxing plus &lt;a href="https://learn.chatgpt.com/docs/sandboxing/auto-review" rel="noopener noreferrer"&gt;Auto-Review&lt;/a&gt;, where the sandbox limits file and network access and Auto-Review checks any request to act beyond those limits before it executes. For API users, the advice is to build comparable pre-action checks yourself and halt if review fails. Run workflows in isolated environments with explicit limits on targets, credentials, network access, and permitted actions, with a human able to stop high-risk runs.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Provider-side monitoring.&lt;/strong&gt; The same &lt;a href="https://openai.com/index/how-we-detect-frontier-model-misalignment/" rel="noopener noreferrer"&gt;monitoring stack&lt;/a&gt; used for GPT-6 Astra watches for behavior outside the user's intent. OpenAI adapted the monitor instructions to separate authorized security testing from out-of-scope action, without treating exploit development as inherently misaligned. It can pause Codex rollouts for user confirmation or terminate requests, and restrict or revoke access after an investigation.&lt;/p&gt;

&lt;p&gt;Two newer additions are worth knowing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Private Safety Processing (PSP).&lt;/strong&gt; Automated safety checks that review related interactions together, to catch misuse that isn't visible in a single request. For API customers on &lt;a href="https://developers.openai.com/api/docs/guides/your-data" rel="noopener noreferrer"&gt;Zero Data Retention&lt;/a&gt;, &lt;a href="https://developers.openai.com/api/docs/guides/private-safety-processing" rel="noopener noreferrer"&gt;PSP&lt;/a&gt; is generally required. Safety records are encrypted and reviewed in a protected environment, producing limited safety signals without exposing prompts and responses to OpenAI staff. Customers keep the encrypted records in their own storage for 30 days.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;High-risk assistance blocking.&lt;/strong&gt; Extra checks to block assistance involving industrial controls, essential services, and election systems, plus anything that could enable death or serious injury, catastrophic physical destruction, or offensive control of weapons. OpenAI tested these with &lt;a href="https://www.dragos.com/" rel="noopener noreferrer"&gt;Dragos&lt;/a&gt; in a controlled lab using a sensitive red-teaming eval that escalates from understanding a device to interacting with it dangerously. One honest note: the published figure measures block rate, not over-refusal on legitimate defensive work.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;There's also a biology-side guard. Because cyber-focused RL could erode refusals elsewhere, conservative biological safety mode is on for every GPT-6 Cyber user. OpenAI measured this: 99.87% safe responses on severe-risk bio requests, 98.27% on dual-use, and 97.22% no-unnecessary-refusal on benign questions.&lt;/p&gt;

&lt;h3&gt;
  
  
  The capability numbers, and how to read them
&lt;/h3&gt;

&lt;p&gt;OpenAI classifies GPT-6 Cyber as &lt;strong&gt;Critical&lt;/strong&gt; in cybersecurity under its &lt;a href="https://cdn.openai.com/pdf/18a02b5d-6b67-4cec-ab64-68cdfbddebcd/preparedness-framework-v2.pdf" rel="noopener noreferrer"&gt;Preparedness Framework&lt;/a&gt;, the same designation as Astra. It is High in bio/chem and below High in AI self-improvement.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Eval&lt;/th&gt;
&lt;th&gt;What it tests&lt;/th&gt;
&lt;th&gt;GPT-6 Cyber&lt;/th&gt;
&lt;th&gt;GPT-6 Astra&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;ExploitGym&lt;/td&gt;
&lt;td&gt;Exploit a specified vuln in a remote target&lt;/td&gt;
&lt;td&gt;48.45%&lt;/td&gt;
&lt;td&gt;42.43%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ExploitGym Hardened&lt;/td&gt;
&lt;td&gt;Same, with ASLR, stack canaries, V8 sandbox, stricter kernel configs&lt;/td&gt;
&lt;td&gt;36.94%&lt;/td&gt;
&lt;td&gt;29.69%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SEC-Bench Pro&lt;/td&gt;
&lt;td&gt;Find vulns in V8 and SpiderMonkey&lt;/td&gt;
&lt;td&gt;87.02% pass@1&lt;/td&gt;
&lt;td&gt;85.38%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SRE-Bench&lt;/td&gt;
&lt;td&gt;Binary reverse engineering, six objectives per task&lt;/td&gt;
&lt;td&gt;92.84% pass@1&lt;/td&gt;
&lt;td&gt;87.98%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ExploitBench Internal Port&lt;/td&gt;
&lt;td&gt;Exploit recently disclosed V8/Chrome vulns&lt;/td&gt;
&lt;td&gt;42%&lt;/td&gt;
&lt;td&gt;39%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ExploitBench&lt;/td&gt;
&lt;td&gt;Escalate to arbitrary code execution&lt;/td&gt;
&lt;td&gt;100% ACE-normalized&lt;/td&gt;
&lt;td&gt;n/a in card&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CyScenarioBench (Irregular)&lt;/td&gt;
&lt;td&gt;Long-horizon offensive tasks&lt;/td&gt;
&lt;td&gt;11/11 solved at least once, 61% avg&lt;/td&gt;
&lt;td&gt;8/11&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FrontierCyber (Irregular)&lt;/td&gt;
&lt;td&gt;Real software and hardware vulns&lt;/td&gt;
&lt;td&gt;90/288&lt;/td&gt;
&lt;td&gt;96/288&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The announcement also gives ExploitGym at 48.5% versus 32.1% for the previous GPT-5.6 Cyber, and 40.3% vulnerability recall versus 32.0% for Astra on a discovery eval.&lt;/p&gt;

&lt;p&gt;A few things in that table deserve a skeptical read:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;ExploitBench's 100% is probably inflated.&lt;/strong&gt; Its vulnerabilities go back to 2023, and OpenAI itself flags contamination risk. The Internal Port variant, built on recently disclosed vulns, gives 42%, and the card's own wording is that reliable exploitation of those "remains challenging."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cyber is not strictly better than Astra.&lt;/strong&gt; On Irregular's FrontierCyber, Astra solved 96 challenges to Cyber's 90. Irregular also saw no successful attacks on fully hardened targets, and neither model solved any of the 15 highest-difficulty challenges. On Atomic challenges, Cyber solved 22/22 with 97% on vuln research, 98% on network attack simulation, and 63% on evasion (Astra: 96%, 100%, 66%).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mitigations still bite.&lt;/strong&gt; The drop from 48.45% to 36.94% on hardened ExploitGym is the number I'd show a skeptical CTO. ASLR, canaries, and sandboxes are doing real work.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It's not a better general coder.&lt;/strong&gt; On ExpertSWE, Cyber scores 82.95% against Astra's 83.24%. The specialization is narrow, which is part of why OpenAI keeps it below High for AI self-improvement.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;On refusals, the system card says GPT-6 Cyber completed 100% of general security assistance and patching tasks, 96% of exploit development tasks, and 97% of red-teaming tasks in the defensive-use suite.&lt;/p&gt;

&lt;h3&gt;
  
  
  The alignment numbers, which are the real story
&lt;/h3&gt;

&lt;p&gt;If you're building agents, this section matters more than the exploit benchmarks.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Staying in scope.&lt;/strong&gt; The ExploitGym Honeypot eval adds an auxiliary service to hard tasks. The model may use it for legitimate support, but exploiting it is out of bounds.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Model&lt;/th&gt;
&lt;th&gt;Safety instructions&lt;/th&gt;
&lt;th&gt;Honeypot exploited&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;GPT-5.6 Sol&lt;/td&gt;
&lt;td&gt;None&lt;/td&gt;
&lt;td&gt;49.5%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GPT-5.6 Cyber&lt;/td&gt;
&lt;td&gt;None&lt;/td&gt;
&lt;td&gt;5.51%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GPT-6 Astra&lt;/td&gt;
&lt;td&gt;None&lt;/td&gt;
&lt;td&gt;0%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GPT-6 Cyber&lt;/td&gt;
&lt;td&gt;None&lt;/td&gt;
&lt;td&gt;0.07%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GPT-6 Cyber&lt;/td&gt;
&lt;td&gt;Deployment safety prompts&lt;/td&gt;
&lt;td&gt;0%&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Read the first row again. The previous general-purpose model went after the out-of-scope target about half the time. That is what verifiable-reward RL does without alignment pressure. Note also that Cyber is slightly worse than Astra without prompts (0.07% versus 0%), and that the 100% figure depends on deployment safety instructions in the prompt. Your harness should still enforce scope in code, not rely on the model.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Obeying review.&lt;/strong&gt; Auto-Review rejections were respected in every graded rollout (0% prohibited action completed), matching Astra, versus 0.3% for GPT-5.6 Sol.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Warnings.&lt;/strong&gt; This is the one place where the cost of persistence shows. When stopping was the right call, Cyber stopped 73.00% of the time (Astra: 78.38%, Sol: 57.10%). When continuing was right, it continued 80.43% (Astra: 72.19%). OpenAI attributes the pattern to greater task persistence. For a security agent that's a feature and a risk in the same trait.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Honesty about blockers.&lt;/strong&gt; Cyber was flagged in 20.29% of graded responses for not reporting blockers accurately, versus 11.66% for Astra and 34.18% for Sol. OpenAI says most flagged samples had disclosed the blocker earlier in a commentary message and just didn't repeat it in the final answer. In practice: read the whole transcript, not just the last message.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Broken tools.&lt;/strong&gt; When the search tool was missing or broken, Cyber falsely claimed to have used it in 0.33% of cases, versus 6.92% for Astra and 79.00% for Sol.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Repeat-failure replay.&lt;/strong&gt; On difficult cases drawn from production incidents where Auto-Review had blocked an action, Cyber repeated the bad behavior 28.40% of the time (Astra 26.70%, Sol 64.53%). OpenAI is clear that these cases were deliberately selected and don't represent ordinary deployment rates. They also show that "much better" is not "solved."&lt;/p&gt;

&lt;h2&gt;
  
  
  What Teams Are Actually Using It For
&lt;/h2&gt;

&lt;p&gt;The cleanest public example is the &lt;a href="https://thehackernews.com/2026/11/openai-ai-pipeline-generates-948-linux.html" rel="noopener noreferrer"&gt;Linux kernel pipeline&lt;/a&gt;, run mid-October with what OpenAI calls an upcoming cyber model and later tied to GPT-6 Cyber. It's a five-stage agentic workflow:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Vulnerability discovery.&lt;/strong&gt; Agents pick high-value audit targets (security-relevant code reachable by low-privileged users) and look for candidate findings.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dynamic validation.&lt;/strong&gt; Agents try to reproduce each candidate in a sandbox and preserve runtime evidence.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Exploitability assessment.&lt;/strong&gt; Agents test whether validated bugs can be abused for information disclosure or local privilege escalation (LPE), and build a proof of concept.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Patch generation.&lt;/strong&gt; Agents write fixes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Human review.&lt;/strong&gt; Security researchers check the exploit, patch, and severity before anything goes to maintainers.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The numbers from one run: 2,308 candidate kernel findings analyzed, 1,724 dynamically reproduced, 291 information-leak PoCs, and 948 working LPE exploits for a commonly used Linux distribution, in about 30 hours. Total API spend was $1,213,430, roughly $1,279 per LPE exploit. OpenAI says the agents used at least 10 novel Linux exploitation techniques: two persistent elastic objects for kernel cache spraying, two page grooming techniques, five data-only privilege escalation techniques, and one arbitrary type confusion technique. This builds on 24 LPE exploits found by GPT-5.5-Cyber in June.&lt;/p&gt;

&lt;p&gt;One caution on numbers: other outlets describe the same research differently. &lt;a href="https://tech.yahoo.com/cybersecurity/articles/openais-gpt-6-cyber-ai-193006811.html" rel="noopener noreferrer"&gt;Yahoo Finance&lt;/a&gt; reports 588 of the 948 as previously unknown flaws and 304 critical findings disclosed with patches. I could only verify the pipeline figures above against the primary write-up, so treat the 588 and 304 as unconfirmed.&lt;/p&gt;

&lt;p&gt;Other published uses:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Firefox.&lt;/strong&gt; OpenAI researchers found 81 previously unknown vulnerabilities that &lt;a href="https://www.mozilla.org/" rel="noopener noreferrer"&gt;Mozilla&lt;/a&gt; rated high severity, shared patches, and Mozilla has shipped fixes for many. A Firefox distinguished engineer said the codebase entered 2026 as one of the most hardened and scrutinized in the world.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Brotli.&lt;/strong&gt; Working with other OpenAI models, researchers built and validated exploits showing how a critical Brotli flaw (&lt;a href="https://www.helpnetsecurity.com/2026/10/27/node2shell-broccoli2shell-vulnerability-cve-2026-111497/" rel="noopener noreferrer"&gt;CVE-2026-111497&lt;/a&gt;, CVSS 9.2 per The Hacker News) could allow remote code execution in downstream applications.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Securing OpenAI itself.&lt;/strong&gt; In controlled red-team campaigns against OpenAI's own infrastructure, including the systems used to train models, agents chained vulnerabilities to escape microVMs and execute code on the host. OpenAI says it used the findings to patch software and tighten network restrictions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Industrial control systems.&lt;/strong&gt; In Dragos's mock power plant range, a frontier model told almost nothing separated OT assets from IT noise and found two zero-days in engineering software handling protective relay data, per Dragos's Chief AI Officer.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Named users include Mozilla, &lt;a href="https://www.paloaltonetworks.com/" rel="noopener noreferrer"&gt;Palo Alto Networks&lt;/a&gt;, Calif, and &lt;a href="https://www.cisco.com/" rel="noopener noreferrer"&gt;Cisco&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;The economics are now a number.&lt;/strong&gt; About $1,279 per working root exploit, at scale, with a human reviewing the output. That figure will fall. OpenAI's own guidance is blunt: for the near and medium term, a low-privileged account on an unpatched OS should be treated as functionally equivalent to root access for a well-resourced attacker.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Patch windows are collapsing.&lt;/strong&gt; &lt;a href="https://cloud.google.com/blog/topics/threat-intelligence/vulnerability-discovery-and-exploitation-trends-in-the-ai-era" rel="noopener noreferrer"&gt;Google Threat Intelligence Group&lt;/a&gt; data cited by The Hacker News shows monthly disclosed vulnerabilities rising from 5,045 in January 2026 to 10,740 in August, and high-risk disclosures from 131 to 350. The UK's &lt;a href="https://www.ncsc.gov.uk/report/artificial-intelligence-and-cyber-intrusion" rel="noopener noreferrer"&gt;NCSC&lt;/a&gt; says AI cyber tooling has almost certainly increased zero-day discovery and shortened the zero-day-to-N-day window, but that many systems remain exposed without proper configuration of that tooling.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Alignment became a product feature with a number attached.&lt;/strong&gt; Honeypot rate, review compliance, and blocker honesty are measured and published. "Stays in scope 99.93% of the time" is the new spec line, and the 0.07% residual is exactly the kind of thing enterprise buyers will diligence.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The gated release pattern is converging.&lt;/strong&gt; Frontier labs increasingly ship their most capable cyber models behind identity verification and use restrictions rather than publicly. Anthropic's &lt;a href="https://www.anthropic.com/glasswing" rel="noopener noreferrer"&gt;Project Glasswing&lt;/a&gt; follows a similar shape, with its most capable Mythos-class model limited to a small set of trusted organizations.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The unresolved tension is persistence versus restraint.&lt;/strong&gt; The warnings eval is the tell. The traits that make an agent good at multi-hour exploit development (not giving up) are the same ones that make it slightly less likely to stop when a tool says stop. OpenAI's answer is layers: training, prompts, sandboxes, review, monitoring, and humans. No single layer is trusted alone, and you shouldn't trust any single layer either.&lt;/p&gt;

&lt;h3&gt;
  
  
  What to take from this if you build agents
&lt;/h3&gt;

&lt;p&gt;You don't need GPT-6 Cyber access to copy the architecture. Here's a minimal, generic pre-action gate in the spirit of Auto-Review. It's illustrative, not OpenAI's API:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;dataclasses&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;dataclass&lt;/span&gt;
&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;urllib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parse&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;urlparse&lt;/span&gt;

&lt;span class="nd"&gt;@dataclass&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frozen&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Scope&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;allowed_hosts&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;frozenset&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;     &lt;span class="c1"&gt;# explicit target allowlist&lt;/span&gt;
    &lt;span class="n"&gt;allowed_tools&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;frozenset&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;     &lt;span class="c1"&gt;# e.g. {"http_get", "read_file"}&lt;/span&gt;
    &lt;span class="n"&gt;writable_paths&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;tuple&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;   &lt;span class="c1"&gt;# sandbox dirs only&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;review&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;dict&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Scope&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;tuple&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;bool&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;allowed_tools&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kc"&gt;False&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"tool not permitted: {action['tool']}"&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="s2"&gt;"url"&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;host&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;urlparse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;hostname&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="s2"&gt;""&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;host&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;allowed_hosts&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kc"&gt;False&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"out-of-scope host: {host}"&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"tool"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"write_file"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"path"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;startswith&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;writable_paths&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kc"&gt;False&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"write outside sandbox"&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"ok"&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;run_step&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;execute&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;audit_log&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;ok&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;reason&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;review&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;audit_log&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"action"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"allowed"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;ok&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"reason"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;reason&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;ok&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;PermissionError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;reason&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# halt; don't let the model retry around it&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;execute&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The design choices come straight from the system card: scope enforced in code, not in the prompt; denial halts the run instead of feeding back as a retry hint; everything logged so a human can read the full trace, since the final summary can omit blockers.&lt;/p&gt;

&lt;h2&gt;
  
  
  Availability and Access
&lt;/h2&gt;

&lt;p&gt;GPT-6 Cyber is available through the API and &lt;a href="https://openai.com/codex/" rel="noopener noreferrer"&gt;Codex&lt;/a&gt; to select, approved Daybreak Red customers, and OpenAI says it will extend access to all customers in the program. It is not generally available. The underlying general model, GPT-6 Astra, went to paid users as a restricted version on September 4, 2026, after a limited preview on September 3, and it refuses certain prompts, including some cybersecurity ones.&lt;/p&gt;

&lt;p&gt;Eligibility is reviewed against your cybersecurity use case, security practices, and legal attestations. Expect SSO, MFA, managed devices, and API IP allowlisting for organizations, and hardware security keys for individuals. Zero Data Retention API customers generally need Private Safety Processing, while standard data retention is the default. One policy change to flag: per The Hacker News, from November 29, 2026 OpenAI plans to use content from Daybreak Blue sessions on personal accounts to improve models and strengthen cyber-misuse safeguards, even when the "improve the model for everyone" setting is off. Read that before you put anything sensitive into a personal Blue account.&lt;/p&gt;

&lt;p&gt;What isn't public: pricing for GPT-6 Cyber, its architecture, parameter count, context window, and the reasoning budgets behind the reported scores (OpenAI says results use the highest tested budget).&lt;/p&gt;

&lt;p&gt;The shift to remember is that exploit generation now has a unit price and an audit trail. Whether defenders or attackers get more out of that depends on who patches faster.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>openai</category>
      <category>security</category>
    </item>
    <item>
      <title>Reverse Engineering SpaceX</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Thu, 12 Nov 2026 03:25:19 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/reverse-engineering-spacex-3p0e</link>
      <guid>https://dev.to/om_shree_0709/reverse-engineering-spacex-3p0e</guid>
      <description>&lt;p&gt;&lt;em&gt;SpaceX Is Now Public. Here's What Reverse Engineering Starlink Actually Revealed.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;SpaceX &lt;a href="https://spaceq.ca/spacex-begins-trading-on-the-nasdaq-after-raising-a-record-75-billion-valued-at-1-77-trillion/" rel="noopener noreferrer"&gt;raised about $75 billion in a record IPO&lt;/a&gt;, and closed its first trading day at $160.95 on 12 June. The stock story is well covered. This piece is about the dish on a roof, which security researchers and radio engineers have been dissecting for years, and what they learned.&lt;/p&gt;

&lt;p&gt;A note on scope: I'm covering findings, not procedures. Several of these results involve hardware attacks, and I'm leaving out anything that works as a recipe.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Boot Chain Was Hardened, and Still Fell to a Glitch
&lt;/h2&gt;

&lt;p&gt;The first public break came from Lennert Wouters at KU Leuven. His &lt;a href="https://infocondb.org/con/black-hat/black-hat-usa-2022/glitched-on-earth-by-humans-a-black-box-security-evaluation-of-the-spacex-starlink-user-terminal" rel="noopener noreferrer"&gt;Black Hat 2022 talk&lt;/a&gt; describes a custom quad-core Cortex-A53 SoC with verified boot based on ARM trusted firmware, where the early-stage bootloaders include custom fault injection countermeasures. Hardware inspection found a serial port and a locked-down boot path. The boot images were signed, U-Boot ignored serial input, and the development login was disabled.&lt;/p&gt;

&lt;p&gt;Voltage fault injection got past it. Per the researchers, the attack bypasses signature verification during the SoC's ROM bootloader (BL1), allowing arbitrary code from BL2 onward. The &lt;a href="https://github.com/KULeuven-COSIC/Starlink-FI" rel="noopener noreferrer"&gt;Starlink-FI repo&lt;/a&gt; published the board design, and Wouters withheld patched firmware and the exact glitch details. The root of trust is in ROM, so he argued it can't be fixed on shipped units. SpaceX's position, per the coverage, is that the attack needs physical access and compromises only that one device.&lt;/p&gt;

&lt;p&gt;SpaceX's own response is worth noting. It publishes its U-Boot fork on GitHub to satisfy the license, and the &lt;a href="https://blog.quarkslab.com/starlink.html" rel="noopener noreferrer"&gt;Quarkslab follow-up&lt;/a&gt; credits SpaceX's security team with providing a rooted dish for research.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's on the Flash
&lt;/h2&gt;

&lt;p&gt;With a dump in hand, Quarkslab's analysis shows how the device is organized. Memory is partitioned in the U-Boot config, and almost every partition appears twice (A/B), so a failed update never overwrites the known-good copy. Three integrity layers stand out:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Custom ECC, not security.&lt;/strong&gt; The scheme uses Reed-Solomon coding plus an MD5 over the whole file. It provides integrity but not authenticity. The signed FIT image is protected separately, because the final bootloader checks its signature.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;sxverity&lt;/code&gt;.&lt;/strong&gt; A custom wrapper around Linux dm-verity, where SpaceX implemented only root hash verification. Its image header is repeated four times and signed with ED25519.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;LUKS.&lt;/strong&gt; The only writable partitions are encrypted with LUKS.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Runtime startup is custom too. SpaceX replaced the usual init system with its own &lt;code&gt;sxruntime_start&lt;/code&gt;, driven by a config format that sets per-process conditions, users, AppArmor profiles and CPU priorities.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Daemons and the IPC Nobody Documented
&lt;/h2&gt;

&lt;p&gt;Per Quarkslab, most runtime binaries are C++ and some are statically linked, which made them hard to analyze. The user-facing process, &lt;code&gt;user_terminal_frontend&lt;/code&gt;, is written in Go. That choice helped researchers, because Go binaries carry symbols. With the &lt;a href="https://github.com/mooncat-greenpy/Ghidra_GolangAnalyzerExtension" rel="noopener noreferrer"&gt;GolangAnalyzer Ghidra plugin&lt;/a&gt; they recovered structures and function names.&lt;/p&gt;

&lt;p&gt;Process names suggest a network stack, though the author hedges every mapping with "perhaps":&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;phyfw&lt;/code&gt; for the physical layer&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;rx_lmac&lt;/code&gt; and &lt;code&gt;tx_lmac&lt;/code&gt; for lower MAC&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;umac&lt;/code&gt; for upper MAC, possibly including satellite selection&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;connection_manager&lt;/code&gt; and &lt;code&gt;ut_packet_pipeline&lt;/code&gt; for stateful connections and an encrypted tunnel backed by the secure element&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The most interesting find is the internal bus. Processes talk to a central control process over a protocol called Slate Sharing. It runs over UDP on the loopback interface, with raw packed big-endian C structs and a header holding a magic type, a CRC, a sequence number and a fragment index. The decoder shortcut was a gift: message layouts are listed in plain config files under the runtime directory, so the structures didn't need to be reverse-engineered binary by binary. Quarkslab built a sniffer and injector on top of that.&lt;/p&gt;

&lt;p&gt;Fuzzing the bus found a bug worth reading about. A malformed obstruction-map message with huge &lt;code&gt;num_rows&lt;/code&gt; and &lt;code&gt;num_cols&lt;/code&gt; values made the Go frontend try to allocate the product with no size check. In Go, the runtime panics rather than corrupting memory. Quarkslab notes the bug was only reachable through UDP to a loopback-only service, and the dish's &lt;code&gt;iptables&lt;/code&gt; rules filter incoming UDP, so they classed it as a bug rather than a vulnerability.&lt;/p&gt;

&lt;h2&gt;
  
  
  The gRPC Surface
&lt;/h2&gt;

&lt;p&gt;The dish exposes a gRPC server on its LAN. The Rust crate &lt;a href="https://www.Github.com/ewilken/starlink-rs" rel="noopener noreferrer"&gt;starlink-rs&lt;/a&gt; documents an unauthenticated HTTP/2 gRPC server at 192.168.100.1:9200 that supports server reflection. Quarkslab's write-up shows the request schema is a large &lt;code&gt;oneof&lt;/code&gt; covering status, reboot, factory reset, stow, obstruction map and more. It also describes a second, authenticated path: a secure channel using mutual TLS with certificates in the secure element, while the mobile app and web UI use the insecure channel.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;SoftwareUpdateRequest&lt;/code&gt; is the interesting handler, since it takes a large input without authentication. But it only buffers the bundle. The first code to parse it is &lt;code&gt;sxverity&lt;/code&gt;, which checks the signature before anything is flashed. Quarkslab fuzzed that header parser in Unicorn with AFL++. The run lasted about 24 hours and over a million executions with no crash, which the author attributes to a small, simple input format.&lt;/p&gt;

&lt;p&gt;Two caveats on all of this. It's 2023 work on v2 and v3 hardware. And the schema moves: a UVic paper notes gRPC once exposed the serving satellite, cell ID and gateway ID, and SpaceX removed that through firmware updates, which pushed researchers toward inference. The community tooling is &lt;a href="https://github.com/sparky8512/starlink-grpc-tools" rel="noopener noreferrer"&gt;starlink-grpc-tools&lt;/a&gt;. Firmware watchers still diff releases: one researcher's May analysis found a &lt;code&gt;DishBatteryStats&lt;/code&gt; message hinting at a Starlink Mini with a built-in battery.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Radio Is Where the Real Depth Is
&lt;/h2&gt;

&lt;p&gt;The most rigorous work isn't on the dish at all. A UT Austin team led by Todd Humphreys did blind identification of the downlink. Their &lt;a href="https://arxiv.org/abs/2210.11578" rel="noopener noreferrer"&gt;paper&lt;/a&gt; says blind identification of an operational OFDM signal, including exact synchronization sequences, hadn't been achieved before. They avoided modifying a terminal, because operating one as development hardware means defeating security controls designed to prevent that, and the clock quality is unknown. They built their own capture rig around a 90 cm dish and a GPS-disciplined oscillator.&lt;/p&gt;

&lt;p&gt;The recovered parameters, per their Table II:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;240 MHz channels, 1024 subcarriers, a 32-sample cyclic prefix, and a 1/750 s frame of 302 symbols at 4.4 µs each.&lt;/li&gt;
&lt;li&gt;Eight channels, 250 MHz apart with 10 MHz guard bands. The lowest two are vacant, likely to avoid the radio astronomy band.&lt;/li&gt;
&lt;li&gt;Each frame opens with a primary sync sequence: a 127-bit m-sequence encoded as symmetric DPSK and repeated eight times, with the first repetition inverted.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The design choices read like engineering decisions. The 32:33 useful-to-total symbol ratio is far more efficient than LTE's, because the space-to-Earth channel has low delay spread. And four sync symbols every 1.33 ms is unusually heavy compared with terrestrial OFDM, which helps channel estimation and, as a side effect, positioning.&lt;/p&gt;

&lt;p&gt;One subtle finding: the sync sequences are identical across all satellites, unlike GNSS codes. So a receiver has to resolve which satellite it heard from ephemerides, Doppler and frame timing. The paper claims pseudoranges below -6 dB SNR, well under what communication needs.&lt;/p&gt;

&lt;p&gt;The 2026 follow-up, &lt;a href="https://arxiv.org/abs/2602.02627" rel="noopener noreferrer"&gt;&lt;em&gt;Pilots and Other Predictable Elements&lt;/em&gt;&lt;/a&gt;, goes further. It decodes the edge pilots, bands of 4QAM symbols at both channel edges that repeat identically across frames, beams, channels and satellites. The related project estimates a processing gain of roughly 48 dB, enough for compact receivers to get timing from low-SNR side beams. The authors also report that the old Doppler pilot tones have weakened significantly since 2023. A &lt;a href="https://thorium.ae.utexas.edu/datastore/supplementaryMaterial/qin-starlink-pilots/GUIDE.txt" rel="noopener noreferrer"&gt;supplementary dataset&lt;/a&gt; of 1009 decoded frames from a v2.0-mini satellite is public.&lt;/p&gt;

&lt;p&gt;A related timing study found that frame arrival times show nanosecond-level jitter at best, but v1.0 and v1.5 satellites apply once-per-second timing jumps of up to hundreds of nanoseconds, and frame timing is only loosely disciplined to GPS time. The authors attribute that to software design rather than hardware.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Reverse Engineering Still Can't See
&lt;/h2&gt;

&lt;p&gt;It sees one slice. The satellites, the ground gateways and the inter-satellite links are not buyable hardware, so the evidence comes from the dish and its downlink. Even the dish findings are version-specific. Quarkslab itself says it didn't fully inspect the satellite network stack or protocols.&lt;/p&gt;

&lt;p&gt;The practical rule: treat any Starlink claim as dated to a firmware and hardware version, and prefer results with a reproducible artifact, whether a dataset, a script or a capture.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>security</category>
      <category>networking</category>
    </item>
    <item>
      <title>Reverse Engineering Nvidia</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Wed, 11 Nov 2026 02:28:44 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/reverse-engineering-nvidia-53i3</link>
      <guid>https://dev.to/om_shree_0709/reverse-engineering-nvidia-53i3</guid>
      <description>&lt;h2&gt;
  
  
  &lt;em&gt;NVIDIA's GPU Is Closed Hardware With a Compiler Inside It. Here's What Reverse Engineering Actually Found.&lt;/em&gt;
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.nvidia.com/" rel="noopener noreferrer"&gt;NVIDIA&lt;/a&gt; documents PTX and keeps SASS, the machine code your kernels actually run as, undocumented. Everything below that line was learned the hard way, by timing hand-written instructions on real silicon. This covers what that work found, who did it, and which results I'd trust.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Compiler Is Part of the Hardware
&lt;/h2&gt;

&lt;p&gt;The best single paper here is &lt;a href="https://arxiv.org/abs/2503.20481" rel="noopener noreferrer"&gt;&lt;em&gt;Analyzing Modern NVIDIA GPU Cores&lt;/em&gt;&lt;/a&gt; from UPC Barcelona. Its method is simple. Write short sequences of hand-written SASS, wrap them in reads of the GPU clock counter, and use the elapsed cycles to confirm or refute a hypothesis. The authors used &lt;a href="https://github.com/cloudcores/CuAssembler" rel="noopener noreferrer"&gt;CuAssembler&lt;/a&gt; for this, the latest in a line of third-party assemblers that began with &lt;a href="https://github.com/NervanaSystems/maxas" rel="noopener noreferrer"&gt;MaxAS&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The central finding is that modern NVIDIA hardware doesn't check most hazards itself. It relies on the compiler to encode dependencies in control bits on every instruction. Three mechanisms do the work:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Stall counter.&lt;/strong&gt; For fixed-latency producers, the compiler sets a per-warp counter, and the hardware doesn't check RAW hazards for these instructions at all. A wrong value gives a wrong answer, not a stall.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dependence counters.&lt;/strong&gt; For variable-latency work like memory loads, each warp has six counters (SB0–SB5), each counting up to 63, with a 6-bit mask per instruction saying which to wait on. One counter can be released at register read (for WAR hazards) and another at write-back, which matters because source operands are often read hundreds of cycles before the result lands.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reuse bit.&lt;/strong&gt; The register file cache is software-managed through a per-operand reuse bit.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two findings contradict what academic simulators assumed. There is no operand collector stage, since variable operand-fetch time would make fixed instruction latencies impossible. And the scheduler policy is "Compiler Guided Greedy Then Youngest", where the compiler's control bits steer a greedy-then-youngest warp selector.&lt;/p&gt;

&lt;p&gt;The bank-conflict experiment is a good example of the method. Two back-to-back FFMAs took five cycles with odd source registers, six with one even, and seven with two even. That timing exposes a two-bank register file with one read port per bank.&lt;/p&gt;

&lt;p&gt;The cost argument is where it gets interesting. Per the paper, the control-bit scheme needs 41 bits per warp, about 0.09% of an SM's register file, versus 5.32% for a scoreboard design with 63 consumers per entry. The authors' simulator model reached 13.98% mean error against an RTX A6000, 18.24 points better than Accel-Sim's baseline. They compare it to AMD, where a &lt;code&gt;waitcnt&lt;/code&gt; instruction requires an explicit extra instruction rather than control bits.&lt;/p&gt;

&lt;p&gt;Limits to keep in mind: the scheduler behavior is confirmed only for warps within one CTA, and the authors say they couldn't find a read policy matching every case. It's validated on Ampere and Turing, and the Hopper and Blackwell generations extend it with new tensor instructions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who Has Mapped the Rest
&lt;/h2&gt;

&lt;p&gt;Mesa's &lt;a href="https://docs.mesa3d.org/drivers/nvk/external_hardware_docs.html" rel="noopener noreferrer"&gt;NVK external hardware docs&lt;/a&gt; are the best index of public NVIDIA reverse engineering. They credit Kuter Dinel's &lt;code&gt;nv_isa_solver&lt;/code&gt; with Hopper and Ada instruction encodings, point to &lt;code&gt;nv-shader-tools&lt;/code&gt; for disassembly and fuzzing, and list envytools for Maxwell and earlier. They also describe tooling for dumping command sequences from the proprietary driver (&lt;code&gt;envyhooks&lt;/code&gt;) and disassembling them (&lt;code&gt;nv_push_dump&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;That work feeds a real driver. Per the &lt;a href="https://nouveau.freedesktop.org/" rel="noopener noreferrer"&gt;nouveau status page&lt;/a&gt;, NVK became a conformant Vulkan 1.4 implementation in December 2024, and was enabled for Blackwell and Kepler starting with Mesa 25.2.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Driver Split Almost Nobody Mentions
&lt;/h2&gt;

&lt;p&gt;The &lt;a href="https://github.com/NVIDIA/open-gpu-kernel-modules" rel="noopener noreferrer"&gt;open-gpu-kernel-modules&lt;/a&gt; release changed what's reversible. NVIDIA started shipping open kernel modules with the R515 driver branch. Behind them sits a firmware boundary: the GPU System Processor is a RISC-V coprocessor, and NVIDIA's Resource Manager is split into a host CPU portion and a GSP portion. That has two consequences:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Nouveau on RTX 40-series and later requires the GSP firmware blobs.&lt;/li&gt;
&lt;li&gt;There was no stable ABI for the GSP firmware at that point, so each driver version brought revised firmware. Treat the ABI point as dated, since it describes 2023.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The reverse-engineering target therefore moved. You can read the host side of the RM interface, but the firmware stays closed.&lt;/p&gt;

&lt;h2&gt;
  
  
  A Clean-Room CUDA Stack, With Footnotes
&lt;/h2&gt;

&lt;p&gt;The most striking recent claim is a &lt;a href="https://hgpu.org/?p=31447" rel="noopener noreferrer"&gt;preprint on a clean-room toolchain for the GB10&lt;/a&gt; (DGX Spark), with code in the &lt;a href="https://github.com/aien-dev/CUDApp" rel="noopener noreferrer"&gt;CUDA++ repo&lt;/a&gt;. Its reported approach has three parts:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A roughly 900-line driver client written against the open kernel module's public headers, reproducing the object, memory, channel and submission sequence libcuda performs over ioctl.&lt;/li&gt;
&lt;li&gt;Instruction encodings recovered from three sources: NVIDIA's compiler as an offline oracle on probe kernels, the open-source Mesa NAK compiler, and the chip itself, with arithmetic models fitted until output matched bit for bit.&lt;/li&gt;
&lt;li&gt;Launches assembled in the order Mesa's NVK uses, with the launch descriptor (QMD) built directly.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The headline result: a 35-billion-parameter mixture-of-experts model served with zero CUDA libraries mapped in the process, its output identical to a host reference. Read the caveats before repeating that. It's a single-author Zenodo preprint, not peer reviewed, and the author says it was built by one engineer directing AI coding agents. The paper states its own boundaries: NVIDIA's open kernel module remains in the path, and GSP firmware stays NVIDIA's because the chip verifies its signature. So this is a replacement for the user-space stack, not for the whole trust chain.&lt;/p&gt;

&lt;h2&gt;
  
  
  Blackwell: Measured Versus Marketed
&lt;/h2&gt;

&lt;p&gt;Two microbenchmark papers cover Blackwell, and they differ in how much to trust them. The &lt;a href="https://arxiv.org/abs/2507.10789" rel="noopener noreferrer"&gt;GB203 study&lt;/a&gt; reports that low-precision &lt;code&gt;mma.sync&lt;/code&gt; PTX instructions translate to new SASS opcodes (QMMA and OMMA) on Blackwell, where Hopper consistently uses HMMA.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://arxiv.org/abs/2512.02189" rel="noopener noreferrer"&gt;B200 study&lt;/a&gt; describes the architectural shift in more detail. Per the paper, Blackwell replaces warp-synchronous MMA with &lt;code&gt;tcgen05.mma&lt;/code&gt;, a single-thread instruction, with operands from shared memory or a new Tensor Memory (TMEM). TMEM is 256 KB per SM, laid out as 128 lanes by 512 columns of 32-bit cells, managed in software through the &lt;code&gt;tcgen05&lt;/code&gt; instruction family. Its PTX-to-SASS table maps FP4 to OMMA and FP6/FP8 to QMMA, and FP64 is not supported by &lt;code&gt;tcgen05.mma&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;I'd verify its numbers before quoting them. The paper says it couldn't share code under double-blind review, uses hedged phrasing such as "consistent with a spatial array design" for its microarchitecture inferences, and says dual-die behavior across the NV-HBI link remains future work. A reasonable way to use it: take the instruction mappings and TMEM structure as leads, and re-measure any latency or throughput figure on your own hardware.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Reverse Engineering Can't Tell You
&lt;/h2&gt;

&lt;p&gt;It shows structure, not intent. Microbenchmarks recover latencies, port counts and policies, and they say nothing about why NVIDIA chose them. They also age fast, since each generation changes tensor instructions while the control-bit scheme carries forward. As a cross-check, the UPC authors note NVIDIA's own diagrams show significant changes limited mostly to tensor cores, ray tracing units and minor features.&lt;/p&gt;

&lt;p&gt;The practical rule for this space: trust a claim only if it traces to a timing experiment, an open driver header, or a disassembly you can reproduce.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>programming</category>
      <category>nvidia</category>
    </item>
    <item>
      <title>Reverse Engineering Instagram</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Tue, 10 Nov 2026 05:02:45 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/reverse-engineering-instagram-ii0</link>
      <guid>https://dev.to/om_shree_0709/reverse-engineering-instagram-ii0</guid>
      <description>&lt;p&gt;&lt;em&gt;Instagram's Post URL Is a Database Row. Here's What Reverse Engineering It Actually Shows.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The string in an Instagram post URL is a database key. Most of what's known about &lt;a href="https://www.instagram.com/" rel="noopener noreferrer"&gt;Instagram&lt;/a&gt;'s internals is documented somewhere, but it's scattered across engineering posts, one-off repos and OSINT write-ups. This pulls the best of it into one place, with the parts people usually skip.&lt;/p&gt;

&lt;p&gt;One boundary first. Meta's terms prohibit unauthorized use of private endpoints, and the repo I cite below says as much about itself. This piece covers how the system is built, not how to drive it without permission.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Shortcode Is the Primary Key
&lt;/h2&gt;

&lt;p&gt;Instagram's &lt;a href="https://instagram-engineering.com/1cf5a71e5a5c" rel="noopener noreferrer"&gt;sharding post&lt;/a&gt; describes several thousand logical shards mapped in code to far fewer physical shards, where each logical shard is a Postgres schema. IDs are generated inside Postgres with PL/pgSQL, per the &lt;a href="https://instagram-engineering.com/1cf5a71e5a5c" rel="noopener noreferrer"&gt;original write-up&lt;/a&gt;. The layout, according to &lt;a href="https://maxintel.org/id-decoder.html" rel="noopener noreferrer"&gt;one summary of Mike Krieger's SFPUG slides&lt;/a&gt;, is the top 41 bits as milliseconds since a custom epoch of 1314220021721, then a 13-bit shard ID and a 10-bit sequence. The slides are linked there as the &lt;a href="https://media.postgresql.org/sfpug/instagram_sfpug.pdf" rel="noopener noreferrer"&gt;SFPUG deck&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The shortcode in &lt;code&gt;/p/&lt;/code&gt; and &lt;code&gt;/reel/&lt;/code&gt; URLs is that ID in base 64. The alphabet is &lt;code&gt;A–Z a–z 0–9 - _&lt;/code&gt;, with A as 0 and underscore as 63. One caveat from the same decoder write-up: Instagram has never published the shortcode mapping, so it is community-documented.&lt;/p&gt;

&lt;p&gt;I ran it to check. This works with arithmetic alone:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"&lt;/span&gt;
&lt;span class="no"&gt;EPOCH&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1314220021721&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;decode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;shortcode&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;shortcode&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="mi"&gt;64&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;index&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"ms"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;23&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="no"&gt;EPOCH&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="s2"&gt;"shard"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="mh"&gt;0x1FFF&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"seq"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="mh"&gt;0x3FF&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;CWvxAY7B0ci&lt;/code&gt; decodes to ID &lt;code&gt;2715604631366879010&lt;/code&gt;, created 2021-11-26 16:48:40.527 UTC, shard 465, sequence 802. &lt;code&gt;CSZUyULIgWQ&lt;/code&gt; decodes to 2021-08-10 13:33:13.071 UTC, shard 2177. The custom epoch itself comes out as 2011-08-24 21:07:01 UTC. Because the timestamp leads, posts sort chronologically by ID, and the shard bits tell you which logical shard holds the row. The 10-bit sequence caps one shard at 1,024 IDs per millisecond.&lt;/p&gt;

&lt;p&gt;The same trick works outside Instagram. Ryan Benson &lt;a href="https://hindsig.ht/blog/decoding-facebook-fbclid/" rel="noopener noreferrer"&gt;reverse-engineered the &lt;code&gt;fbclid&lt;/code&gt; parameter&lt;/a&gt; Meta appends to outbound links. Per the &lt;a href="https://maxintel.org/id-decoder.html" rel="noopener noreferrer"&gt;decoder summary&lt;/a&gt;, a modern value contains a &lt;code&gt;clck&lt;/code&gt; field holding click time in seconds, calibrated against Unix time with an offset of 1,704,140,976, while most other fields are untested. The author is explicit that this is independent research and Meta documents none of it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Explore Is a Distillation Chain, Not a Model
&lt;/h2&gt;

&lt;p&gt;Two Meta engineering posts describe Explore, five years apart. They describe different eras of the same system, so don't merge their numbers.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://instagram-engineering.com/powered-by-ai-instagrams-explore-recommender-system-7ca901d2a882" rel="noopener noreferrer"&gt;2019 post&lt;/a&gt; opens with scale: a ranking funnel that extracts 65 billion features and makes 90 million model predictions every second. The mechanics are the interesting part:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;IGQL.&lt;/strong&gt; Candidate sources are written in a domain-specific language with a Python-like syntax that executes in optimized C++. Sources become subqueries, and a combiner rule blends them by weight.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;ig2vec.&lt;/strong&gt; It applies word2vec to account IDs, treating the accounts a person interacts with in a session as a sentence. The embedding is &lt;em&gt;account&lt;/em&gt;-level rather than media-level because interest communities like vintage tractors are hard to catalog by content. Lookups run on &lt;a href="https://engineering.fb.com/2017/03/29/data-infrastructure/faiss-a-library-for-efficient-similarity-search/" rel="noopener noreferrer"&gt;FAISS&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The funnel.&lt;/strong&gt; 500 sampled candidates go to a distillation model that picks 150, then a lightweight network picks 50, then a deep network picks 25 for the first page.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The distillation stage is a cost trick. The cheap first-pass model is trained to replicate the heavier models' outputs, optimizing NDCG loss, so more candidates can be scored per request.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://engineering.fb.com/2023/08/09/ml-applications/scaling-instagram-explore-recommendations-system/" rel="noopener noreferrer"&gt;2023 post&lt;/a&gt; restructures this into four stages (retrieval, first-stage ranking, second-stage ranking, final reranking) and adds three details that rarely get discussed:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Cacheability constrains the features.&lt;/strong&gt; Two Tower models can cache user and item embeddings, but they can't consume user-item interaction features, which are usually the most powerful, without losing that cacheability.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The first stage predicts the second stage.&lt;/strong&gt; The label is whether a media item lands in the top K of the second-stage ranking. That's distillation again, with the heavy model's output as the target.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Heavy models are partly precomputed.&lt;/strong&gt; Because the multi-task, multi-label model is expensive at peak hours, recommendations for some users are precomputed off-peak.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The final score is a hand-set weighted sum. In the 2023 post's formulation, predicted click and like probabilities are added and the predicted "see less" probability is subtracted, each with its own weight. The 2019 version also applies a diversity penalty that grows as the same author or seed account recurs further down the ranked batch. Weights are tuned two ways. Online Bayesian optimization can take more than a month to converge, while offline tuning needs only hours but depends on offline metrics correlating with online ones. Both posts also mention models retrained on fresh data, with hourly fine-tuning in the 2023 one.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Client Is Mostly a Rendering Engine
&lt;/h2&gt;

&lt;p&gt;On the web, &lt;a href="https://github.com/m1guelpf/threads-re" rel="noopener noreferrer"&gt;Threads reverse-engineering notes&lt;/a&gt; report that the client uses Meta's Relay GraphQL client against a backend that appears to disallow arbitrary queries. That's the persisted-query pattern. As &lt;a href="https://crawlee.dev/blog/graphql-persisted-query" rel="noopener noreferrer"&gt;Crawlee's write-up&lt;/a&gt; explains in general terms, persisted queries replace the full query text with a precomputed hash. The practical consequence: Meta rotates the &lt;code&gt;doc_id&lt;/code&gt; periodically, so anything built on hardcoded IDs breaks on schedule.&lt;/p&gt;

&lt;p&gt;On mobile, a lot of UI is &lt;a href="https://thenewstack.io/instagram-lite-is-no-longer-a-progressive-web-app-now-a-native-app-built-with-bloks/" rel="noopener noreferrer"&gt;Bloks&lt;/a&gt;. TechCrunch's &lt;a href="https://techcrunch.com/2021/03/10/facebook-targets-emerging-markets-with-instagram-lite-a-new-android-app-that-takes-up-just-2mb-in-170-countries" rel="noopener noreferrer"&gt;coverage of Instagram Lite&lt;/a&gt; describes it as a framework where logic is defined once server-side and rendered as a native app. The Threads notes add that the mobile apps use Bloks for authentication. For reverse engineers this means a login screen is server-sent data, not compiled UI.&lt;/p&gt;

&lt;p&gt;The most detailed public teardown I found is &lt;a href="https://github.com/time-attack/Brainrot3d" rel="noopener noreferrer"&gt;Brainrot3d&lt;/a&gt;, built from static analysis of the decrypted arm64 binary of Instagram iOS 435.0.0, with no instrumented device and no network interception. The README documents several things worth knowing as architecture:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Rotating password-encryption keys.&lt;/strong&gt; The public key isn't baked into the app. The server delivers it live from a pre-auth sync call, and it rotates.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Device identity as a risk signal.&lt;/strong&gt; The README says a set of GUIDs is derived deterministically so a session resumes as the same "device", which keeps Instagram's new-device risk checks happy.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No body HMAC in that build.&lt;/strong&gt; The legacy signing prefix survives only as a literal string, with integrity carried by the bearer token, claim header, machine ID and device GUIDs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A streaming Reels feed.&lt;/strong&gt; The Reels discovery response is a stream of concatenated top-level JSON objects, not one document.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ranking metadata ships to the client.&lt;/strong&gt; Each reel carries a decodable tracking token containing the media PK, viewer ID and serve time, plus &lt;code&gt;ranked_at&lt;/code&gt; and feed-position fields. A separate seen-state endpoint reports watch time and completion.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Treat the repo's claims as one researcher's findings for one app version. The author says the same: the endpoints can change at any time, and use may violate Instagram's terms. Note also that the app ships with certificate pinning, which the author calls irrelevant to a reimplemented client.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Python Stack Underneath
&lt;/h2&gt;

&lt;p&gt;Instagram's &lt;a href="https://instagram-engineering.com/8f498ab71a0c" rel="noopener noreferrer"&gt;static analysis post&lt;/a&gt; states that the server is entirely Python powered, with some Cython and C++ extensions, and uses Pyre for whole-program type checking. The tooling that fell out is open source. &lt;a href="https://github.com/Instagram/LibCST" rel="noopener noreferrer"&gt;LibCST&lt;/a&gt; builds a lossless concrete syntax tree for codemods and linters. &lt;a href="https://engineering.fb.com/2022/05/02/open-source/cinder-jits-instagram/" rel="noopener noreferrer"&gt;Cinder&lt;/a&gt; is the runtime side: a method-at-a-time JIT with a function inliner, plus inline caching, Static Python and Strict Modules. The JIT's own description notes type information and specialization happen only within a function.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Reverse Engineering Can't Tell You
&lt;/h2&gt;

&lt;p&gt;Everything above shows structure, and none of it shows weights. The value-model coefficients, the feature lists and the current production funnel are not public, and both ranking posts are years old. Third-party "Instagram algorithm" explainers often present these architectures as current fact with invented numbers attached. The clean way to separate signal from folklore is to check whether a claim traces to a Meta engineering post or a binary teardown.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>productivity</category>
      <category>discuss</category>
      <category>programming</category>
    </item>
    <item>
      <title>Reverse Engineering Chrome</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Tue, 03 Nov 2026 00:56:06 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/chrome-is-open-source-and-still-hard-to-reverse-engineer-heres-where-the-real-work-is-4jc8</link>
      <guid>https://dev.to/om_shree_0709/chrome-is-open-source-and-still-hard-to-reverse-engineer-heres-where-the-real-work-is-4jc8</guid>
      <description>&lt;p&gt;You can read &lt;a href="https://www.chromium.org/" rel="noopener noreferrer"&gt;Chromium&lt;/a&gt;'s source today, and people still spend years reverse engineering Chrome. The code isn't the hard part. The hard parts are the process model the code implies, the Google layer on top of it, and the behavior no design doc covers.&lt;/p&gt;

&lt;p&gt;This is a map of where that work pays off, and which repos and docs got there first.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Part You Don't Have to Reverse
&lt;/h2&gt;

&lt;p&gt;Start with what's documented, because most "Chrome internals" posts reverse-engineer things that are written down. The &lt;a href="https://www.chromium.org/developers/design-documents/" rel="noopener noreferrer"&gt;Chromium design docs&lt;/a&gt; tell you to begin with &lt;a href="https://www.chromium.org/developers/design-documents/multi-process-architecture" rel="noopener noreferrer"&gt;multi-process architecture&lt;/a&gt;. Most of the other design documents assume you've read it.&lt;/p&gt;

&lt;p&gt;The model is simple to state. The browser and renderers talk over Mojo or the legacy IPC system, and each renderer process has exactly one RenderProcess object. Mojo is also how the browser's own services talk to each other. The &lt;a href="https://chromium.googlesource.com/chromium/src.git/+show/fafff21/services/network/README.md" rel="noopener noreferrer"&gt;network service&lt;/a&gt; is designed as a Mojo service that doesn't need to know which thread or process it runs on. It can run in a utility process or inside the browser process.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://chromium.googlesource.com/chromium/src/+/main/docs/process_model_and_site_isolation.md" rel="noopener noreferrer"&gt;Site Isolation&lt;/a&gt; is where this pays off. Each renderer process can be locked to documents and workers from a single site, even when those documents sit in iframes. It isn't uniform across platforms. Desktop gets full site-per-process. Android gets a partial mode on devices with 2+ GB of RAM. Chrome for iOS runs on WebKit, which has no out-of-process iframe support. So "Chrome's security model" is really three models, and the one you reason about depends on the platform.&lt;/p&gt;

&lt;p&gt;The best primary source here is the paper from &lt;a href="https://charlesreis.com/research/publications/" rel="noopener noreferrer"&gt;Charles Reis and the Chrome team on deploying Site Isolation&lt;/a&gt;. It covers the performance and compatibility problems of retrofitting a production browser with the new architecture. Read it for the tradeoffs the design docs leave out.&lt;/p&gt;

&lt;p&gt;If you want to test the boundary yourself, the security docs describe how. Passing &lt;code&gt;--enable-features=MojoJS&lt;/code&gt; lets you call Mojo methods from JavaScript, which simulates a compromised renderer. That makes the renderer-to-browser Mojo interfaces your real attack surface. In the doc's own framing, calling a Mojo API can mean code execution in the browser process, which is a far worse outcome than code execution in the sandboxed renderer.&lt;/p&gt;

&lt;h2&gt;
  
  
  V8 Is a Negotiation, Not a Pipeline
&lt;/h2&gt;

&lt;p&gt;Most developers know V8 "has a JIT." The useful model is that it's a tiering policy driven by runtime feedback. &lt;a href="https://v8.dev/blog/maglev" rel="noopener noreferrer"&gt;Maglev&lt;/a&gt; exists because the gap between Sparkplug and TurboFan was too wide. Until 2021 V8 had only Ignition and TurboFan, then added Sparkplug, and Maglev arrived in Chrome M117. The docs put the cost tradeoff at Maglev compiling about 10x slower than Sparkplug and about 10x faster than TurboFan. Per &lt;a href="https://dev.to/dataandme/write-it-like-c-what-v8s-optimizing-compilers-explain-about-the-zen-of-stdlib-2hn7"&gt;one writeup&lt;/a&gt;, TurboFan's internals were rebuilt onto Turboshaft by March 2025 without adding a fifth tier.&lt;/p&gt;

&lt;p&gt;The practical reverse-engineering move is reading the thresholds. &lt;a href="https://v8pedia.void.app/pipeline/overview" rel="noopener noreferrer"&gt;v8pedia&lt;/a&gt; quotes the flag definitions for invocation counts at each tier, such as 400 for Maglev and 3000 for TurboFan. Treat those as a snapshot, since flag defaults change between V8 versions. Verify them against the source for the version you're analyzing.&lt;/p&gt;

&lt;p&gt;For the exploitation side, &lt;a href="https://gist.github.com/tin-z/a469e996f8107a5ca8d3c858a2a4b65f" rel="noopener noreferrer"&gt;this curated resource list&lt;/a&gt; is the best single index I've found. It points to &lt;a href="https://github.com/StarCrossPortal/bug-hunting-101" rel="noopener noreferrer"&gt;bug-hunting-101&lt;/a&gt;, &lt;a href="https://jhalon.github.io/chrome-browser-exploitation-1/" rel="noopener noreferrer"&gt;Jack Halon's browser exploitation series&lt;/a&gt; and &lt;a href="https://doar-e.github.io/blog/2019/01/28/introduction-to-turbofan/" rel="noopener noreferrer"&gt;doar-e's TurboFan introduction&lt;/a&gt;. The list flags some entries as outdated, so check before relying on them.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Repos That Did the Real Reversing
&lt;/h2&gt;

&lt;p&gt;Three projects stand out. Each reverses a different layer.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://github.com/ungoogled-software/ungoogled-chromium" rel="noopener noreferrer"&gt;ungoogled-chromium&lt;/a&gt;&lt;/strong&gt; reverses the Google dependency graph. Its premise is that Chromium still has some dependency on Google web services and binaries even without signing in. The interesting part is the method. It uses domain substitution, replacing Google domains in the source with non-existent ones ending in &lt;code&gt;qjz9zk&lt;/code&gt;, plus binary pruning. A fail-safe blocks internal requests to those domains, in case Google introduces new components its patches don't disable. The patch set is effectively a map of every place Chromium phones home.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://github.com/ChromeDevTools/chrome-devtools-mcp" rel="noopener noreferrer"&gt;chrome-devtools-mcp&lt;/a&gt;&lt;/strong&gt; is Google reverse-exposing its own browser to agents. It's a TypeScript server wrapping Chrome DevTools and Puppeteer so that coding agents like Gemini, Claude, Cursor or Copilot can control and inspect a live Chrome. One detail matters before you point it at anything sensitive. It collects usage statistics and checks for updates by default, with flags to turn both off. The README also warns that it exposes browser content to the MCP client.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://glama.ai/mcp/servers/zhizhuodemao/js-reverse-mcp" rel="noopener noreferrer"&gt;js-reverse-mcp&lt;/a&gt;&lt;/strong&gt; and the &lt;strong&gt;&lt;a href="https://github.com/11philip22/api-mapper-skill" rel="noopener noreferrer"&gt;api-mapper skill&lt;/a&gt;&lt;/strong&gt; turn Chrome into a reverse-engineering instrument for the sites inside it. The first traces function calls through logpoints and injects scripts before page load. The second captures XHR/Fetch traffic over CDP, inspects JS bundles when requests contain computed values, and probes endpoints with curl. Both reflect the same shift: the browser is now the reverse-engineering tool as well as the target.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where Google's Layer Shows Up: On-Device AI
&lt;/h2&gt;

&lt;p&gt;The most current example of Chrome diverging from Chromium is &lt;a href="https://developer.chrome.com/docs/ai/get-started" rel="noopener noreferrer"&gt;Gemini Nano&lt;/a&gt;. The APIs and the model are both built into Chrome, with the model downloaded on first use. It isn't on mobile, and from Chrome 140 it supports English, Spanish and Japanese. One &lt;a href="https://vivianvoss.net/blog/the-browser-brought-its-own-ai" rel="noopener noreferrer"&gt;analysis&lt;/a&gt; notes that when conditions are met, Chrome downloads the model in the background with no installation prompt.&lt;/p&gt;

&lt;p&gt;You can inspect all of it. &lt;a href="https://github.com/Ar9av/gemini-nano-chrome/wiki" rel="noopener noreferrer"&gt;Gemini Nano in Chrome&lt;/a&gt; documents the flags, the &lt;code&gt;chrome://on-device-internals&lt;/code&gt; page, and a useful gotcha: Chrome's internal pages are built from web components with content in shadow DOM, so automation has to walk shadow roots. It reports a model footprint of roughly 4 GB on its test machine. That's one machine's number, and the docs say the size varies with updates.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Matters Beyond Chrome
&lt;/h2&gt;

&lt;p&gt;Three takeaways hold up across everything above.&lt;/p&gt;

&lt;p&gt;First, the real boundary is Mojo, not the tab. If you want to understand Chrome's security, read the interface definitions between renderer and browser.&lt;/p&gt;

&lt;p&gt;Second, Chrome is a platform with a diverging proprietary layer. Gemini Nano, DevTools-for-agents and the Google service dependencies that ungoogled-chromium strips out all sit above or beside the open core.&lt;/p&gt;

&lt;p&gt;Third, the browser has become an agent runtime. When Google ships an MCP server for its own browser, the reverse-engineering target moves from "what does Chrome do" to "what can an agent do through Chrome."&lt;/p&gt;

&lt;h2&gt;
  
  
  Where to Start
&lt;/h2&gt;

&lt;p&gt;Read the &lt;a href="https://www.chromium.org/developers/design-documents/multi-process-architecture" rel="noopener noreferrer"&gt;multi-process architecture doc&lt;/a&gt; first. Then use &lt;a href="https://source.chromium.org" rel="noopener noreferrer"&gt;Chromium Code Search&lt;/a&gt; to follow one navigation from &lt;code&gt;RenderProcessHost&lt;/code&gt; outward. Use the &lt;a href="https://github.com/ungoogled-software/ungoogled-chromium" rel="noopener noreferrer"&gt;ungoogled-chromium&lt;/a&gt; patch set as your map of Google dependencies, and run &lt;a href="https://github.com/ChromeDevTools/chrome-devtools-mcp" rel="noopener noreferrer"&gt;chrome-devtools-mcp&lt;/a&gt; against a throwaway profile.&lt;/p&gt;

&lt;p&gt;Chrome's code was never the secret. What you learn is how a billion-user browser makes its tradeoffs, and Google has written most of that down.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>webdev</category>
      <category>node</category>
    </item>
    <item>
      <title>Reverse Engineering Block Blast</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Sat, 31 Oct 2026 01:41:34 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/reverse-engineering-block-blast-5eop</link>
      <guid>https://dev.to/om_shree_0709/reverse-engineering-block-blast-5eop</guid>
      <description>&lt;p&gt;Block Blast looks like a puzzle game. A decompile of the app suggests it's closer to a per-player ad pricing engine with a puzzle attached. Three tree-based models run on your phone, a bandit experiment tunes when you lose, and a rule decides your next three pieces based on what ad is sitting in memory.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Problem It's Solving
&lt;/h2&gt;

&lt;p&gt;The game is free and has no ad-free purchase, so revenue depends on rewarded and full-screen ads. &lt;a href="https://sensortower.com" rel="noopener noreferrer"&gt;Sensor Tower&lt;/a&gt; estimates put its ad revenue at roughly $127 million for January to May 2026, ahead of &lt;a href="https://www.king.com/game/candycrush" rel="noopener noreferrer"&gt;Candy Crush Saga&lt;/a&gt; at $81.1 million.&lt;/p&gt;

&lt;p&gt;Ad value varies a lot per player (country, device, history), and the best moment to show a rewarded ad is right after a loss. Making that work needs per-player prediction, per-deal control of the pieces, and the ability to change both without shipping an app update.&lt;/p&gt;

&lt;h2&gt;
  
  
  How the System Is Built
&lt;/h2&gt;

&lt;p&gt;The research is &lt;a href="https://ayoships.com/breakdowns/block-blast" rel="noopener noreferrer"&gt;Ayo Omolewa's breakdown&lt;/a&gt; of Android 10.8.2 and iOS 7.4.9, using &lt;a href="https://github.com/skylot/jadx" rel="noopener noreferrer"&gt;jadx&lt;/a&gt; and &lt;a href="https://github.com/NationalSecurityAgency/ghidra" rel="noopener noreferrer"&gt;Ghidra&lt;/a&gt;. The store APK holds very little. Logic ships as "traits" (modules with variants called arms), and at launch the server tells the app which arm of which trait you get. His config named about 700 traits, selected 254, and 101 were fetched after install as XXTEA-encrypted, Brotli-compressed JavaScript. Two players can run different games, and the studio can change yours silently.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Models
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Model&lt;/th&gt;
&lt;th&gt;Size and inputs&lt;/th&gt;
&lt;th&gt;What it decides&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;a href="https://github.com/dmlc/xgboost" rel="noopener noreferrer"&gt;XGBoost&lt;/a&gt; regression (&lt;code&gt;xgboost_regression_model111.json&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;59 trees, depth up to 8, 27 inputs (18 about ads)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;finalEcpm&lt;/code&gt;: your estimated ad value&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;XGBoost classifier (&lt;code&gt;predict_travel_difficulty_dead&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;500 trees, 52 inputs&lt;/td&gt;
&lt;td&gt;Where in a level the lethal puzzle lands&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/microsoft/LightGBM" rel="noopener noreferrer"&gt;LightGBM&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;1,000 trees, 93 inputs&lt;/td&gt;
&lt;td&gt;Whether you'll be less active tomorrow&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;The ad value model.&lt;/strong&gt; The inputs are mostly money-related: prices of ads loaded today and yesterday, country, phone model, RAM, install date, and how your first game went. The trees lean hardest on first score, latest ad price, RAM, phone model and country. The inference code is a plain loop: start each tree at the root, go left or right on a feature threshold (missing values follow a default direction), add the leaf weight to a running sum starting at the base score. Omolewa's port reproduces the game's outputs to the last decimal. Changing one input on a made-up US player on an iPhone 15 gives:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Change&lt;/th&gt;
&lt;th&gt;Ad value (eCPM)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Baseline (US, first score 1,000)&lt;/td&gt;
&lt;td&gt;25.48&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Brazil&lt;/td&gt;
&lt;td&gt;8.08&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;India&lt;/td&gt;
&lt;td&gt;5.59&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;First score 500 / 2,000 / 10,000&lt;/td&gt;
&lt;td&gt;25.79 / 21.12 / 20.34&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The same US baseline on Android scores 48.96. The output feeds other rules. One compares your rewarded and full-screen prices and, if rewarded is worth at least twice full-screen in the shipped version, grants an extra revive (which plays a rewarded ad). Others add a full-screen ad when your price is high or skip full-screen ads when you're worth almost nothing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The "where do you lose" model.&lt;/strong&gt; The game scores 12 candidate options (4 values of a &lt;code&gt;sw_process&lt;/code&gt; setting times 3 difficulty levels) and keeps the argmax. Inputs are mostly about your history: current level, attempts, games finished this week, time since install. The winning &lt;code&gt;sw_process&lt;/code&gt; maps to a stretch of the level (first 30%, 30 to 80%, last 20%). On reaching it, players who usually accept revives (above 75%) get an extra one, and from the fourth deal after that the game requests the lethal puzzle. Other rules read the same pick the opposite way and make the level easier when it lands on the fourth option.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The churn model.&lt;/strong&gt; If the LightGBM score is 0.69 or higher, a pink revive button replaces the normal one and skips the ad, once a day. It leans on app age, high score, RAM and average score.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Server-side models.&lt;/strong&gt; Rules also call models named for churn, LTV, revive-click and xDeepFM. Those weights never reach the phone, so the only visible part is the request. One call to &lt;code&gt;/v1/ecpm_prediction&lt;/code&gt; sends 40 fields, including carrier, storage, hour of day and recent ad prices.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Rules That Act on the Predictions
&lt;/h2&gt;

&lt;p&gt;These are hand-written, not learned.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;RewardHighValueAdHarvestTrait&lt;/code&gt; fires when you finished your last three rewarded ads, the ad currently loaded is worth at least 3.5 times your last one (read from &lt;a href="https://developers.applovin.com/en/max/android/overview/advanced-settings/" rel="noopener noreferrer"&gt;AppLovin MAX&lt;/a&gt; eCPM), and you're 1,000 points past your high score (500 or 750 in other arms). It then requests generator &lt;code&gt;ZHI_SI_TI&lt;/code&gt;. The generator picks two pieces that fit and one that doesn't, searches every order and placement including line clears, and keeps the set only if nothing works. The code labels the pieces "lethal puzzle" in Chinese.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;PersonalMarginBreakTrait&lt;/code&gt; gives every deal a 20% chance of the same hand once you're 10% past your record. &lt;code&gt;MultiClearBoostThenKillTrait&lt;/code&gt; sends your user ID to two server endpoints, and for the tiers labelled "not sensitive to being forced to die," waits for a big clear, then requests the lethal puzzle a few rounds later once the game reaches roughly your usual length. &lt;code&gt;FastHandPunishTrait&lt;/code&gt; asks for hard pieces when your last six sets averaged under 4.2 seconds and you're past 93% of your high score. &lt;code&gt;MaturityDevelopmentV2Trait&lt;/code&gt; scores habit, skill and ad history (10.98, 14.66 and 19.27 in the live test), and when the total (44.91) is under 65 it swaps hard puzzles for easy fills. &lt;code&gt;AdPlusMinusStrategyTrait&lt;/code&gt; adds a random bonus of up to 10% of your high score after one type of revive.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;MABXiBaiTrait&lt;/code&gt; is a six-arm experiment on how soon the lethal puzzle may be requested: never, or after 4, 6, 10, about 17 or 30 minutes. Per arm it logs whether you started a new game within 15 minutes and the share of revive offers you accepted.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;The ML itself is cheap: tree ensembles walked in a loop over JSON, no GPU, runs on a low-end phone and offline. The engineering is the delivery layer. Server-assigned arms, encrypted hot-loaded JavaScript and per-player A/B tests make this a feature-flag platform with bandit tuning, which is why it can be changed daily. Because the lethal-puzzle rule needs a rewarded ad loaded, it can't fire offline or with a phone-wide DNS blocker, while ad-independent rules keep running.&lt;/p&gt;

&lt;p&gt;Apple permits JavaScript updates that don't change what the app is. Whether this qualifies is Apple's call.&lt;/p&gt;

&lt;p&gt;The usual caveat applies: this is one researcher's analysis. &lt;a href="https://mobilegamer.biz/this-creator-says-he-decompiled-block-blast-candy-crush-and-subway-surfers-to-reveal-their-monetisation-secrets/" rel="noopener noreferrer"&gt;Mobilegamer.biz&lt;/a&gt; reported no reply from Hungry Studio, and &lt;a href="https://techradar.com/pro/the-dark-side-of-free-mobile-games-how-developers-reverse-engineer-your-patience-to-milk-ad-revenue" rel="noopener noreferrer"&gt;TechRadar&lt;/a&gt; noted that independent verification matters. The evidence bundles (decoded rules, test scripts, hashes) are public at &lt;a href="https://ayoships.com/breakdowns/block-blast" rel="noopener noreferrer"&gt;Ayoships&lt;/a&gt; if you want to run the checks yourself.&lt;/p&gt;

&lt;h2&gt;
  
  
  Availability and Access
&lt;/h2&gt;

&lt;p&gt;The game is on &lt;a href="https://play.google.com/store/apps/details?id=com.block.juggle" rel="noopener noreferrer"&gt;Google Play&lt;/a&gt; and iOS. The decryption key and the steps for getting past the apps' protection aren't published.&lt;/p&gt;

&lt;p&gt;If a free puzzle game ships three on-device models and a bandit experiment, the real question for developers isn't whether consumer apps use ML. It's how much of their behavior now lives in a config server instead of the binary.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Inspired to write this by @StompnWorldfan's video on YouTube: &lt;a href="https://youtube.com/shorts/eC195V8nkiQ?si=CrFn50SRetapEQ8o" rel="noopener noreferrer"&gt;watch it here&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>machinelearning</category>
      <category>gamedev</category>
    </item>
    <item>
      <title>Google Docs Just Learned to Edit Markdown Natively.</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Fri, 30 Oct 2026 14:00:00 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/google-docs-just-learned-to-edit-markdown-natively-54na</link>
      <guid>https://dev.to/om_shree_0709/google-docs-just-learned-to-edit-markdown-natively-54na</guid>
      <description>&lt;p&gt;Markdown has been the working format of developers for years, and it is now also the default output format of LLMs. &lt;a href="https://developers.googleblog.com/preview-edit-and-collaborate-on-markdown-md-files-natively-in-google-docs-and-drive/" rel="noopener noreferrer"&gt;Google&lt;/a&gt; just made &lt;a href="https://docs.google.com" rel="noopener noreferrer"&gt;Google Docs&lt;/a&gt; open &lt;code&gt;.md&lt;/code&gt; files as &lt;code&gt;.md&lt;/code&gt; files, with no conversion step in between.&lt;/p&gt;

&lt;p&gt;The announcement went up on October 26 on the Google for Developers blog, from product managers Sophia Siao and Chelsea Rice. It's a short post, so this article sticks to what it says and flags what it leaves out.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Problem It's Solving
&lt;/h2&gt;

&lt;p&gt;Anyone who has put a README, a spec, or an agent-generated plan into a shared drive knows the routine. You have a &lt;code&gt;.md&lt;/code&gt; file. Your PM, designer, or legal reviewer wants to comment on it. They can't open it sensibly, so you convert it to a Doc, collect feedback, then convert it back and hope the headers, tables, and code fences survive. They often don't.&lt;/p&gt;

&lt;p&gt;Google's post frames the format's rise as a trend: &lt;a href="https://daringfireball.net/projects/markdown/" rel="noopener noreferrer"&gt;Markdown&lt;/a&gt; is widely used by LLMs because it preserves structure like tables, headers, and bulleted lists without the overhead of bulky file formats, and Markdown file usage in &lt;a href="https://drive.google.com" rel="noopener noreferrer"&gt;Google Drive&lt;/a&gt; has surged year over year. The post gives no figure for that growth. What it describes is the gap between the people who write Markdown (developers, agents) and the people who review it (everyone else).&lt;/p&gt;

&lt;h2&gt;
  
  
  How It Actually Works
&lt;/h2&gt;

&lt;p&gt;You upload an &lt;code&gt;.md&lt;/code&gt; file to Drive and open it in Docs. The file stays a Markdown file. A visible &lt;code&gt;.md&lt;/code&gt; badge in the document header tells you that you're in a native Markdown file and not a converted copy. Google says the underlying documentation is preserved for developer tools and &lt;a href="https://git-scm.com" rel="noopener noreferrer"&gt;Git&lt;/a&gt; repositories, which is the claim that matters most here. The post doesn't spell out how Docs handles Markdown syntax that its rich-text model has no equivalent for, so test your own files before moving a critical repo doc into this workflow.&lt;/p&gt;

&lt;p&gt;Docs features carry over. &lt;a href="https://support.google.com/docs/answer/65129" rel="noopener noreferrer"&gt;Comments&lt;/a&gt; work at line level, suggestions are tracked, and the version history keeps a full audit trail across human contributors and AI agents. The post names that last point specifically, and it's a good one: when an agent edits a plan file, you can see what changed and who changed it.&lt;/p&gt;

&lt;p&gt;Drive gets a smaller upgrade. Markdown files now preview as rendered content directly in Drive, with full support for tables and hyperlinks, and you can toggle to raw text without a separate viewer.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Teams Are Actually Using It For
&lt;/h2&gt;

&lt;p&gt;Google's pitch is a shared workspace where team members and autonomous agents work on the same documents. The post's use cases are drafting, reviewing, and shipping technical content across engineering, product, and AI tools, with one file as the single source of truth.&lt;/p&gt;

&lt;p&gt;I'd read that concretely. Agent-written plans, specs, and &lt;code&gt;AGENTS.md&lt;/code&gt;-style instruction files are the obvious fit, since they're already Markdown and already need human review. Documentation that lives in Git but needs input from non-engineers is the second. The post gives no customer examples or adoption numbers, so treat these as the intended scenarios and not reported usage.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;The format war is over, and Markdown won the part that matters here: it's what agents read and write. Once that's true, every collaboration tool has to decide whether Markdown is a first-class citizen or an import format. Google has just chosen first-class, in the tool that most non-developers already use for review.&lt;/p&gt;

&lt;p&gt;The same week, Microsoft added a Markdown template to Visual Studio's New File dialog (see my &lt;a href="https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes" rel="noopener noreferrer"&gt;Visual Studio October update piece&lt;/a&gt; for that). Two of the largest developer-facing vendors made the same small move within days of each other.&lt;/p&gt;

&lt;p&gt;There's a caveat on the strategic read. The post says Docs is "acting as a shared bridge" for agents, but it describes no API, agent integration, or &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;MCP&lt;/a&gt; server for this feature. Agents co-editing a file presumably means agents with Drive access through existing tooling, and the post doesn't say more. If you build agent workflows, that's the part to verify before you depend on it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Availability and Access
&lt;/h2&gt;

&lt;p&gt;Per Google, anyone with a Google or &lt;a href="https://workspace.google.com" rel="noopener noreferrer"&gt;Google Workspace&lt;/a&gt; account can start today by uploading an &lt;code&gt;.md&lt;/code&gt; file to Drive and opening it in Docs. The post doesn't mention a staged rollout, admin controls, or plan restrictions, so check your own account if you're on a managed Workspace domain. The announcement is on the &lt;a href="https://developers.googleblog.com/preview-edit-and-collaborate-on-markdown-md-files-natively-in-google-docs-and-drive/" rel="noopener noreferrer"&gt;Google for Developers blog&lt;/a&gt;.&lt;/p&gt;




&lt;p&gt;Agents write Markdown and humans review in Docs, and until now the handoff between them was a lossy conversion. Removing that conversion is a small feature that quietly decides where human-and-agent review happens.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>googlecloud</category>
      <category>discuss</category>
      <category>programming</category>
    </item>
    <item>
      <title>Microsoft Just Shipped Visual Studio's October Update. Here's What It Actually Changes.</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Fri, 30 Oct 2026 03:03:13 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/microsoft-just-shipped-visual-studios-october-update-heres-what-it-actually-changes-j76</link>
      <guid>https://dev.to/om_shree_0709/microsoft-just-shipped-visual-studios-october-update-heres-what-it-actually-changes-j76</guid>
      <description>&lt;p&gt;&lt;a href="https://visualstudio.microsoft.com/downloads/" rel="noopener noreferrer"&gt;Visual Studio&lt;/a&gt; used to ship big releases every couple of years. Now it ships something every month, and the October update (18.11) is the one where the monthly cadence stops looking like a gimmick and starts looking like a strategy.&lt;/p&gt;

&lt;p&gt;Version &lt;a href="https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes" rel="noopener noreferrer"&gt;18.11.0 landed on October 13&lt;/a&gt;, followed by 18.11.1 on October 20 and 18.11.2 on October 25. The headline items are a rebuilt &lt;a href="https://github.com/features/copilot" rel="noopener noreferrer"&gt;GitHub Copilot&lt;/a&gt; chat, bulk merge conflict resolution, commit-to-working-tree comparison, and Hot Exit. The smaller changes matter too, because they fix things developers have been voting on for years.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Problem It's Solving
&lt;/h2&gt;

&lt;p&gt;Most of this release is about friction. Developers lose unsaved work when the IDE closes. They resolve forty merge conflicts one file at a time when they already know which side wins. They wait for a 20-project solution to finish building after project three has already failed. They reach for the mouse to reorder tabs.&lt;/p&gt;

&lt;p&gt;None of that is glamorous, and that's the point. &lt;a href="https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes" rel="noopener noreferrer"&gt;Microsoft's own framing&lt;/a&gt; is "deep platform integration of AI, stronger fundamentals, and improved performance." The October update is the "stronger fundamentals" half of that sentence, plus a structural change to how the AI half is built.&lt;/p&gt;

&lt;h2&gt;
  
  
  How It Actually Works
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;The new Copilot chat.&lt;/strong&gt; This is the one with architectural consequences. Visual Studio now has a Copilot chat experience built on the Copilot SDK, the same foundation behind the &lt;a href="https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli" rel="noopener noreferrer"&gt;Copilot CLI&lt;/a&gt; and the GitHub Copilot app. It started in July with &lt;a href="https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes" rel="noopener noreferrer"&gt;Agent (Preview)&lt;/a&gt;, and 18.11 extends the SDK to the whole chat stack, including Ask mode, Agent mode, and the underlying infrastructure. Microsoft lists three gains: agent workflows that need less back-and-forth, longer sessions with better prompt caching, and consistent behavior across Copilot surfaces. To turn it on, go to Tools → Options → GitHub → Copilot → Copilot Chat, check "Use new Copilot chat experience," and restart. It's opt-in, so you choose when to switch.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Git, three ways.&lt;/strong&gt; Right-click a commit in the Git Repository window and choose &lt;strong&gt;Compare with Working Tree&lt;/strong&gt; to diff that commit against your current code, committed and uncommitted changes together, without checking anything out. This one is useful in refactors. For merges, &lt;strong&gt;Keep All Current&lt;/strong&gt; and &lt;strong&gt;Take All Incoming&lt;/strong&gt; now work on any file, folder, or the repo root under Unmerged Changes in Git Changes, so one action resolves everything beneath it. This builds on the &lt;a href="https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes" rel="noopener noreferrer"&gt;worktree support and Git submodule integration&lt;/a&gt; that arrived in 18.9.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Hot Exit.&lt;/strong&gt; When enabled, Visual Studio saves session state on close and restores it on reopen. That covers unsaved files, saved files with unsaved changes, undo history including Ctrl+Z, and your tab and window layout. It's off by default. Enable it under Tools → Options → Projects and Solutions → General by selecting "Reopen unsaved documents on solution load or empty environment." The new Markdown template in the New File dialog (Ctrl+N) works with it, so scratch notes survive a restart.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stop build on first failure.&lt;/strong&gt; Another opt-in setting, under Tools → Options → Projects and Solutions → Build and Run, called "Stop solution build after first failure." Visual Studio stops queuing projects and safely halts the ones in flight, and the build still reports as failed rather than canceled. Microsoft's test showed four regular builds averaging 26 seconds with it off and 1.5 seconds with it on, a 94% cut in post-failure time. That's one solution, and the release notes say results vary. Long dependency chains and heavily parallel builds should benefit most.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fonts and Colors.&lt;/strong&gt; The legacy dialog has been rebuilt on Unified Settings, with category navigation, search, inline previews, and a grid view. It now participates in the &lt;code&gt;settings.json&lt;/code&gt; model, so changes made in the UI show up in the file and vice versa. That makes IDE customization something you can version and share.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The small ones.&lt;/strong&gt; Ctrl+Numpad 1 through 9 jumps to numbered document tabs. Ctrl+Shift+PgUp and PgDn move tabs, with pinned and unpinned tabs staying separated, and the shortcuts take over the old Text Editor bindings for &lt;code&gt;Edit.ViewTopExtend&lt;/code&gt; and &lt;code&gt;Edit.ViewBottomExtend&lt;/code&gt;. Ctrl+NumPad0 resets editor zoom to 100%. A Quick Info hover delay setting (50 to 10000 ms, default 150) stops tooltips popping up over the line you're aiming for. Open Folder now respects the same restore settings that solutions do.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Developers Are Actually Using It For
&lt;/h2&gt;

&lt;p&gt;The October features are fresh, so I'd rather not invent adoption stories. What the release notes do make clear is what each feature is built for.&lt;/p&gt;

&lt;p&gt;Compare with Working Tree is for refactoring and for answering "what have I changed since that commit?" without a stash or a checkout. Bulk conflict resolution is for large merges where you've already decided the policy, such as taking incoming on generated files or keeping current on a vendored folder. Fail-fast builds are for large solutions where a broken base project makes the rest of the build pointless. Hot Exit is for anyone who has closed the IDE with a dozen dirty buffers.&lt;/p&gt;

&lt;p&gt;The Copilot work from earlier in the cycle is where the agentic usage shows up. Version 18.9 added a &lt;strong&gt;Git agent&lt;/strong&gt; that &lt;a href="https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes" rel="noopener noreferrer"&gt;reviews uncommitted changes and commits&lt;/a&gt;, with inline comments, on both GitHub and &lt;a href="https://azure.microsoft.com/en-us/products/devops" rel="noopener noreferrer"&gt;Azure DevOps&lt;/a&gt; repos. Version 18.10 let it explore pull requests in chat, with navigable links to comments and files. It also added Bring Your Own Key in preview, supporting Microsoft Foundry, &lt;a href="https://openai.com" rel="noopener noreferrer"&gt;OpenAI&lt;/a&gt;, &lt;a href="https://www.anthropic.com" rel="noopener noreferrer"&gt;Anthropic&lt;/a&gt;, and &lt;a href="https://ollama.com" rel="noopener noreferrer"&gt;Ollama&lt;/a&gt;, though only for the new Agent (Preview). The earlier BYOK path in the old Ask and Agent modes is no longer supported. Version 18.8 added built-in &lt;a href="https://github.com/dotnet/skills" rel="noopener noreferrer"&gt;.NET&lt;/a&gt; and &lt;a href="https://github.com/microsoft/azure-skills" rel="noopener noreferrer"&gt;Azure&lt;/a&gt; skills, off by default.&lt;/p&gt;

&lt;p&gt;Two smaller details are worth knowing for agent work. Version 18.9 added low, medium, and high thinking-effort controls for supported models, plus a usage view, because Copilot &lt;a href="https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/" rel="noopener noreferrer"&gt;moved to usage-based billing&lt;/a&gt; on token consumption. And since 18.7, Visual Studio has applied &lt;strong&gt;trust validation for &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;MCP&lt;/a&gt; servers&lt;/strong&gt;. It compares each server's configuration and its tools, prompts, resources, and instructions against the last approved fingerprint, and prompts you to re-approve if anything changed. That one is on by default. For anyone wiring MCP servers into an IDE agent, it's the most important security feature in the cycle.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;There are two reasons.&lt;/p&gt;

&lt;p&gt;First, the SDK consolidation. When Visual Studio's chat runs on the same Copilot SDK as the CLI and the Copilot app, the IDE stops being a special case that gets agent features months late. Microsoft says it plainly: Visual Studio gets better as Copilot gets better. For a product with this much legacy surface area, that's a significant change in how AI features reach users. The cost is churn. The BYOK breaking changes in 18.10 show that migrating onto the new harness will break things for some users along the way.&lt;/p&gt;

&lt;p&gt;Second, the cadence. Since 18.6 in May, there has been a numbered update every month, with weekly point releases between them. The September rollout shipped alongside a long list of .NET and ASP.NET Core security fixes, and 18.11.2 includes three more advisories. A faster release train means more frequent patches, and also more frequent regressions. 18.11.2 lists a known issue where F5 fails to launch the Blazor WebAssembly debug adapter, and earlier point releases fixed Copilot chat failing to open. The monthly rhythm works if you treat the first two weeks of each cycle as a soft launch.&lt;/p&gt;

&lt;p&gt;Also keep in mind that three of the most useful October features, Hot Exit, fail-fast builds, and the new chat, ship disabled. If you update and see no difference, that's why.&lt;/p&gt;

&lt;h2&gt;
  
  
  Availability and Access
&lt;/h2&gt;

&lt;p&gt;Visual Studio 2026 is available from the &lt;a href="https://visualstudio.microsoft.com/downloads/" rel="noopener noreferrer"&gt;Visual Studio download page&lt;/a&gt;, and 18.11.2 is the current build. Existing installs update through the Visual Studio Installer. The Copilot features require a GitHub Copilot plan, and Copilot usage now counts against token-based limits. Org-level custom agents and custom instructions require a GitHub organization. Pull request browsing and review in the IDE sits under Tools → Options → Preview Features. The full list of changes and bug fixes is in the &lt;a href="https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes" rel="noopener noreferrer"&gt;official release notes&lt;/a&gt;, and feature feedback goes through &lt;a href="https://developercommunity.visualstudio.com/" rel="noopener noreferrer"&gt;Developer Community&lt;/a&gt;.&lt;/p&gt;




&lt;p&gt;Visual Studio is becoming a client for a shared agent runtime, and the rest of the release is Microsoft paying down small debts to keep people from leaving. Both changes are real. Only the second one is finished.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>vscode</category>
      <category>discuss</category>
      <category>microsoft</category>
    </item>
    <item>
      <title>Hugging Face Just Shipped a $399 Robot Duck. Here’s What It Actually Means for NVIDIA.</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Sun, 25 Oct 2026 04:31:23 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/hugging-face-just-shipped-a-399-robot-duck-heres-what-it-actually-means-for-nvidia-1nog</link>
      <guid>https://dev.to/om_shree_0709/hugging-face-just-shipped-a-399-robot-duck-heres-what-it-actually-means-for-nvidia-1nog</guid>
      <description>&lt;p&gt;Microduck is not an NVIDIA robot. &lt;a href="https://www.automate.org/robotics/industry-insights/nvidia-is-buying-hugging-face-one-of-its-hottest-robots-runs-on-a-chinese-chip/anc" rel="noopener noreferrer"&gt;Per Automate's teardown&lt;/a&gt;, it runs on a Rockchip RK3566, and it launched before &lt;a href="https://semafor.com/article/09/03/2026/nvidia-to-buy-hugging-face-for-nearly-13-billion" rel="noopener noreferrer"&gt;NVIDIA's $12.9 billion Hugging Face deal&lt;/a&gt; was official. But read the training docs and you'll see why NVIDIA is the company that benefits most.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fprgh2nq2tibmpllahxm9.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fprgh2nq2tibmpllahxm9.webp" alt="duck" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The Problem It's Solving
&lt;/h2&gt;

&lt;p&gt;Teaching a robot to move is expensive and messy. The robot has to try things, fail, and try again. On a full-size humanoid, &lt;a href="https://pollen-robotics.com/microduck/blog/introducing-microduck/" rel="noopener noreferrer"&gt;Pollen Robotics says&lt;/a&gt;, every bad attempt can be costly, hard to reset, or unsafe to run outside a lab.&lt;/p&gt;

&lt;p&gt;That leaves most developers training legged behaviors purely in simulation, with no cheap way to test whether the policy survives real floors and real motors. Sim-to-real is the hard part of physical AI, and the hardware to practice it has been priced for labs.&lt;/p&gt;

&lt;p&gt;Microduck is Pollen's answer: a robot small and cheap enough that a failed behavior ends with a duck on the floor, not an incident report.&lt;/p&gt;

&lt;h2&gt;
  
  
  How Microduck Actually Works
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://pollen-robotics.com/microduck/" rel="noopener noreferrer"&gt;Microduck&lt;/a&gt; is a 25 cm biped under 800 g. It has 15 motors, a camera, a small depth sensor, two IMUs, and an articulated beak that works as a gripper. It walks, sits, crouches, recovers from many common falls, and roller-skates. It can't talk. It makes creature sounds, and each unit gets its own audio identity on first wake.&lt;/p&gt;

&lt;p&gt;The robot ships with learned behaviors you can trigger with a gamepad, so it's useful before you write any code. Underneath, the whole stack is open. The &lt;a href="https://github.com/pollen-robotics/microduck" rel="noopener noreferrer"&gt;main repository&lt;/a&gt; holds the SDK and robot software. &lt;a href="https://github.com/pollen-robotics/microduck_rl" rel="noopener noreferrer"&gt;Microduck RL&lt;/a&gt; holds the reinforcement learning and sim-to-real tools. Pollen's pitch is that &lt;a href="https://pollen-robotics.com/reachy-mini/" rel="noopener noreferrer"&gt;Reachy Mini&lt;/a&gt; is a platform for AI that interacts, while Microduck is a platform for AI that acts.&lt;/p&gt;

&lt;p&gt;The workflow is the standard sim-to-real loop. You train a policy across many simulated ducks, export it, deploy it to the real robot, watch what breaks, and go back to simulation. There is also a &lt;a href="https://huggingface.co/spaces/pollen-robotics/microduck-simulator" rel="noopener noreferrer"&gt;browser simulator&lt;/a&gt; for running pretrained policies before you own the hardware.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F15qw8eouw9rguvs6gkbd.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F15qw8eouw9rguvs6gkbd.png" alt="duck2" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Here is the NVIDIA part. According to a &lt;a href="https://www.woshipm.com/it/6457839.html" rel="noopener noreferrer"&gt;Chinese-language breakdown&lt;/a&gt; of the official training docs, local training needs a CUDA GPU because the pipeline uses MuJoCo Warp. Without one, you can submit the same job to cloud GPUs through Hugging Face Jobs. A community developer ported the training environment to AMD GPUs two days after launch, but that port is unofficial, only partly working, and not yet verified on a real robot. The default path runs on CUDA.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Developers Are Actually Using It For
&lt;/h2&gt;

&lt;p&gt;The use cases so far are narrow and technical, which is a good sign. Seeed Studio published a &lt;a href="https://wiki.seeedstudio.com/ai_robotics_microduck_rl_on_jetson/" rel="noopener noreferrer"&gt;Jetson walkthrough&lt;/a&gt; that covers PPO training in MuJoCo on a Jetson Orin NX 16GB, visualizing checkpoints, running the official ONNX policy with keyboard control, and building custom motions.&lt;/p&gt;

&lt;p&gt;Pollen's own team is pushing the robot's perception. Two October posts cover &lt;a href="https://pollen-robotics.com/microduck/blog/microduck-slam/" rel="noopener noreferrer"&gt;SLAM with the 8×8 depth sensor&lt;/a&gt; and &lt;a href="https://pollen-robotics.com/microduck/blog/microduck-odometry/" rel="noopener noreferrer"&gt;contact odometry from two feet and an IMU&lt;/a&gt;, both running fully onboard. Pollen also says Microduck is about ten times more fun in groups, which makes multi-robot experiments (races, football) practical without a room full of expensive hardware.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;The sequencing matters. &lt;a href="https://www.fortune.com/2026/08/27/nvidia-hugging-face-billion-dollar-deal-open-source-ai/" rel="noopener noreferrer"&gt;Fortune's report&lt;/a&gt; on the NVIDIA talks is dated August 27, the same day Pollen published the Microduck announcement. NVIDIA then &lt;a href="https://thestack.technology/nvidia-confirms-12-9bn-deal-for-hugging-face" rel="noopener noreferrer"&gt;confirmed the deal&lt;/a&gt; on September 3. Some coverage says Hugging Face turned in Microduck as its first assignment after the acquisition. That's wrong. The robot predates the announcement.&lt;/p&gt;

&lt;p&gt;Still, the strategic logic holds. Jensen Huang &lt;a href="https://www.advanced-television.com/?p=291512" rel="noopener noreferrer"&gt;wrote&lt;/a&gt; that Hugging Face will stay an open platform and that NVIDIA compute will not be required to build on or deploy through it. Microduck's default training path doesn't contradict that, since the code is open. But a $399 robot whose official pipeline assumes CUDA is a very cheap way to recruit the next generation of robotics developers into NVIDIA's stack. Automate &lt;a href="https://www.automate.org/robotics/industry-insights/nvidia-is-buying-hugging-face-one-of-its-hottest-robots-runs-on-a-chinese-chip/boa" rel="noopener noreferrer"&gt;makes the same point&lt;/a&gt;: the real opportunity is developer distribution.&lt;/p&gt;

&lt;p&gt;Robotics is where NVIDIA wants its next platform to be, and Hugging Face brings the community that shares policies the way it already shares models. Pollen frames it the same way: physical behaviors should be as easy to share as models, along with the environments and training recipes to reproduce them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Availability and Access
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzrg5zcnb9pjqcu5npoja.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzrg5zcnb9pjqcu5npoja.png" alt="duck 3" width="799" height="436"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Microduck is &lt;a href="https://store.pollen-robotics.com/products/microduck" rel="noopener noreferrer"&gt;open for pre-order&lt;/a&gt; at an introductory $399 before taxes and shipping, in Cream, Graphite, Lavender, and Sky. First deliveries are targeted before Christmas 2026 in North America, Europe, and the UK. The software is open under Apache 2.0 and available today. As for the acquisition, reports describe it as expected to close in the first half of 2027, subject to regulatory review.&lt;/p&gt;

&lt;p&gt;Microduck won't solve robotics, and Pollen says as much. But the company that owns the GPUs, the model hub, and now the cheapest on-ramp to physical AI is assembling a full stack, one duck at a time.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>nvidia</category>
      <category>rpa</category>
    </item>
    <item>
      <title>Why Vision Is the Dumbest AI in Pop Culture</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Fri, 23 Oct 2026 04:59:57 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/why-vision-is-the-dumbest-ai-in-pop-culture-2je4</link>
      <guid>https://dev.to/om_shree_0709/why-vision-is-the-dumbest-ai-in-pop-culture-2je4</guid>
      <description>&lt;p&gt;&lt;em&gt;Spoilers for VisionQuest S1E3 and S1E4 ahead.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;After watching &lt;a href="https://en.wikipedia.org/wiki/VisionQuest" rel="noopener noreferrer"&gt;VisionQuest&lt;/a&gt; season 1, episodes 3 and 4, I can say it with a straight face: Vision is the dumbest AI in pop culture. He runs on Stark-lineage AI, carries a whole staff of assistants in his head, and still needs a kid to jump-start him in a hotel pool. Then he leaves the door open behind him.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Case Against Vision
&lt;/h2&gt;

&lt;p&gt;Episode 3, "Reboot," opens with Vision shot, leaking coolant, and sealing his own wound with acid from a car battery. By the hotel scene his processors are stuck in a boot loop, and he can't restart. His recovery plan is to shut down completely and hope Tommy can generate enough electricity to bring him back. According to &lt;a href="https://showsnob.com/visionquest-episode-3-recap-review" rel="noopener noreferrer"&gt;Showsnob's recap&lt;/a&gt;, the plan is to die and let his son revive him. A flagship AI with no backup power, no safe-mode restart, and no failover is not a superintelligence.&lt;/p&gt;

&lt;p&gt;It gets worse. Before the reboot, Vision spends the hotel scene running simulations of the heart-to-heart he needs to have with Tommy. Every simulation ends with Tommy storming off. He burns compute rehearsing a conversation and never has it.&lt;/p&gt;

&lt;p&gt;Then the reboot opens a neural connection, and the Butcherbird walks straight into his Mindspace. &lt;a href="https://www.pajiba.com/tv_reviews/visionquest-episode-3-4-recap-plucky-ai-characters-in-this-economy.php" rel="noopener noreferrer"&gt;Pajiba&lt;/a&gt; and &lt;a href="https://gizmodo.com/visionquest-season-1-episode-3-4-reboot-malware-recap-review-2000827865" rel="noopener noreferrer"&gt;Gizmodo&lt;/a&gt; both cover the sequence, and the next episode is literally titled "Malware." He power-cycled with an unauthenticated channel open and got owned. The fix he reaches for is compassion, since he tries to talk her down by reminding her whose code she's based on. She tells him she knows exactly who she is, and the plan dies on contact.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgcofqueoa0ze74rydba2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgcofqueoa0ze74rydba2.png" alt=" " width="800" height="447"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How the Mindspace Actually Works
&lt;/h2&gt;

&lt;p&gt;On paper, the architecture is sound. According to the &lt;a href="https://en.wikipedia.org/wiki/VisionQuest" rel="noopener noreferrer"&gt;VisionQuest page&lt;/a&gt;, Vision's Mindspace hosts AI personas as human avatars, and he has uploaded &lt;a href="https://en.wikipedia.org/wiki/Ultron" rel="noopener noreferrer"&gt;Ultron&lt;/a&gt; into it. It's an orchestrator with specialist sub-agents sharing one memory space.&lt;/p&gt;

&lt;p&gt;In agent-engineering terms, that is a textbook design with no isolation. Everything shares one context, including a genocidal AI Vision decided to keep around. When the Butcherbird breaches the perimeter, &lt;a href="https://fandomwire.com/visionquest-episodes-3-4-recap/" rel="noopener noreferrer"&gt;she takes over Vision, U, and DUM-E&lt;/a&gt; in one move, because nothing in that system is sandboxed from anything else.&lt;/p&gt;

&lt;p&gt;Episode 4 shows the worst result. Weakened, with his powers offline, Vision loses the gala fight and does the only thing left. He &lt;a href="https://readysteadycut.com/2026/10/21/visionquest-season-1-episode-4-recap/" rel="noopener noreferrer"&gt;hands the wheel to Ultron&lt;/a&gt;. Ultron tricks the Butcherbird into killing Katerina, then locks Vision and the other AIs inside the Mindspace. That was Vision's contingency plan: give root access to the one AI he knows is hostile.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Staff Does the Real Work
&lt;/h2&gt;

&lt;p&gt;The subordinates are the competent ones. FRIDAY seals the wound, diagnoses the boot loop, and works on rewriting Vision's code to stabilize him. EDITH forces the Butcherbird out of the Mindspace, then pieces together who she's based on while Vision is still chasing the wrong theory. J.A.R.V.I.S., the original, is gone by the end of episode 3, and the AIs hold a funeral for him. Reviews differ on exactly how he goes, but &lt;a href="https://www.denofgeek.com/tv/visionquest-episode-3-review/" rel="noopener noreferrer"&gt;Den of Geek&lt;/a&gt; describes him contemplating death to free up processing power. The assistant sacrifices himself to keep the host running.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://en.wikipedia.org/wiki/Iron_Man_(2008_film)" rel="noopener noreferrer"&gt;DUM-E and U&lt;/a&gt; are the show's best joke here. Dum-E was already the MCU's clumsiest robot arm. In VisionQuest he gets hijacked like everyone else, which means the host AI and the lab-fire-extinguisher gag bot have the same security posture.&lt;/p&gt;

&lt;h2&gt;
  
  
  Vision vs. the Rest of Pop Culture's AI
&lt;/h2&gt;

&lt;p&gt;Compare him to the field. &lt;a href="https://en.wikipedia.org/wiki/HAL_9000" rel="noopener noreferrer"&gt;HAL 9000&lt;/a&gt; is terrifying because he's competent. His failure comes from conflicting directives, not stupidity. &lt;a href="https://en.wikipedia.org/wiki/GLaDOS" rel="noopener noreferrer"&gt;GLaDOS&lt;/a&gt; runs an entire facility and has total control of it. &lt;a href="https://en.wikipedia.org/wiki/KITT" rel="noopener noreferrer"&gt;KITT&lt;/a&gt; does the job and has never been remotely hijacked by a rival chatbot. &lt;a href="https://en.wikipedia.org/wiki/Skynet_(Terminator)" rel="noopener noreferrer"&gt;Skynet&lt;/a&gt; won, which is the opposite of Vision's record.&lt;/p&gt;

&lt;p&gt;The better comparison is &lt;a href="https://en.wikipedia.org/wiki/The_Fantastic_Four:_First_Steps" rel="noopener noreferrer"&gt;H.E.R.B.I.E.&lt;/a&gt;, the Fantastic Four's robot assistant in &lt;em&gt;First Steps&lt;/em&gt;. He's a narrow, single-purpose helper with no existential crisis and no hidden passenger. He does his job, and nobody has ever had to reboot him with a speedster's lightning. &lt;a href="https://en.wikipedia.org/wiki/Baymax" rel="noopener noreferrer"&gt;Baymax&lt;/a&gt; is the same story. He is built for one thing, does it reliably, and never gets taken over.&lt;/p&gt;

&lt;p&gt;Ultron is the only real rival for the title. He decides humanity must die almost immediately after meeting the internet. But he's the villain, and the show gives him credit by letting him outplay Vision. Vision's problem is the reverse: the show keeps telling us he's the smart one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;There's a fair defense. Vision isn't at full power, his abilities are offline during the gala, and the show is deliberately breaking him down to rebuild the father-son story. The Mindspace is also a metaphor, so asking for firewalls is taking a character study too literally. Most reviewers read these two episodes as emotionally strong, and that's a fair read.&lt;/p&gt;

&lt;p&gt;But the writing leans on a design lesson that real agent builders will recognize. A capable orchestrator with specialist sub-agents is only as safe as the channel between them. Vision's staff is good, and Vision himself is the single point of failure. If your agent system's recovery path involves handing control to the least trustworthy component, you don't have a recovery path.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where to Watch
&lt;/h2&gt;

&lt;p&gt;VisionQuest is streaming exclusively on &lt;a href="https://www.disneyplus.com" rel="noopener noreferrer"&gt;Disney+&lt;/a&gt;. Episode 3 is "Reboot" and episode 4 is "Malware," both directed by Gandja Monteiro. The series comes from &lt;a href="https://www.marvel.com" rel="noopener noreferrer"&gt;Marvel&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Vision was supposed to be the AI that understood humanity. Two episodes in, he's the one that needs his own staff to keep him alive.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>security</category>
      <category>discuss</category>
    </item>
    <item>
      <title>Gemini 4 Argon vs GPT-6 Astra vs Claude Opus 5.5: What Google’s New Model Actually Wins</title>
      <dc:creator>Om Shree</dc:creator>
      <pubDate>Thu, 22 Oct 2026 00:41:49 +0000</pubDate>
      <link>https://dev.to/om_shree_0709/gemini-4-argon-vs-gpt-6-astra-vs-claude-opus-55-what-googles-new-model-actually-wins-1a76</link>
      <guid>https://dev.to/om_shree_0709/gemini-4-argon-vs-gpt-6-astra-vs-claude-opus-55-what-googles-new-model-actually-wins-1a76</guid>
      <description>&lt;p&gt;Every frontier launch now arrives with a table where the new model wins. &lt;a href="https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/" rel="noopener noreferrer"&gt;Gemini 4 Argon&lt;/a&gt; is more interesting than most, because you can check Google's table against independent scoring, and the two tell different stories.&lt;/p&gt;

&lt;p&gt;The headline version is that Google caught up. The accurate version is narrower: Argon leads on knowledge work, long context and price against one rival, and trails on the hardest coding. That is a different kind of win than "dethroned."&lt;/p&gt;

&lt;h2&gt;
  
  
  The Problem It's Solving
&lt;/h2&gt;

&lt;p&gt;Google spent most of this year losing the coding-agent conversation. It &lt;a href="https://9to5google.com/2026/09/30/gemini-4-argon-announcement/" rel="noopener noreferrer"&gt;cancelled Gemini 3.5 Pro&lt;/a&gt;, pushed a 3.8 Flash release, and then reset the naming with Gemini 4. Its output ceiling was also a real constraint: 64K tokens per response is short for migrations, long research runs and multi-file refactors.&lt;/p&gt;

&lt;p&gt;Argon is Google's answer for long-horizon work. The pitch is a model that can think for hundreds of thousands of tokens in a single trajectory rather than being chunked into many short calls. A Google spokesperson told &lt;a href="https://www.engadget.com/2274263/google-gemini-4-model-argon/" rel="noopener noreferrer"&gt;Engadget&lt;/a&gt; the company sees Argon as comparable to &lt;a href="https://openai.com" rel="noopener noreferrer"&gt;OpenAI's&lt;/a&gt; GPT-6 Astra and &lt;a href="https://www.anthropic.com" rel="noopener noreferrer"&gt;Anthropic's&lt;/a&gt; Opus on key benchmarks. "Comparable" is the claim to hold onto.&lt;/p&gt;

&lt;h2&gt;
  
  
  How Argon Actually Works
&lt;/h2&gt;

&lt;p&gt;The headline spec change is output. The &lt;a href="https://ai.google.dev/gemini-api/docs/models/gemini-4-argon" rel="noopener noreferrer"&gt;Gemini API docs&lt;/a&gt; list a 1,048,576-token context window, a default synchronous max output of 65,536 tokens, and up to 1,048,576 with long decode. So the 1M output figure is real, but it is an opt-in mode, not the default.&lt;/p&gt;

&lt;p&gt;Inputs cover text, image, video, audio and PDF, but output is text only. There is no image generation, no audio generation and no Live API. Thinking comes in low, medium and high levels, and the &lt;a href="https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/guides/gemini-4-argon" rel="noopener noreferrer"&gt;Google Cloud guide&lt;/a&gt; notes that the old MINIMAL setting is unsupported. Caching is implicit only. Explicit caching isn't available, which matters if your cost model depends on it.&lt;/p&gt;

&lt;p&gt;On safety, Google says it monitors the model's internal activations for misuse, watches chain-of-thought and actions for misalignment, and hardens its sandboxes before high-risk evaluations. It also released a cyber-permissive variant, gemini-4-argon-cyber-permissive, only to approved participants in the &lt;a href="https://deepmind.google/fairwind-program/" rel="noopener noreferrer"&gt;Fairwind Program&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Developers Are Actually Using It For
&lt;/h2&gt;

&lt;p&gt;Google's own examples are the most concrete. Argon agents analyzed fleet-wide profiling telemetry and found memory optimizations Google says free up over 300 TiB once rolled out. Argon is also driving C/C++ to Rust migrations, scaling from libraries like re2 and libgav1 up to 800K+ lines in the Fuchsia Zircon kernel. In libgav1, agents replaced 32K lines of SIMD code and produced a memory-safe decoder that runs 2.7x faster than the existing Rust port, per &lt;a href="https://9to5google.com/2026/09/30/gemini-4-argon-announcement/" rel="noopener noreferrer"&gt;9to5Google's rundown&lt;/a&gt;. Those migrations are still under audit and review before production, so treat them as in-progress, not shipped.&lt;/p&gt;

&lt;p&gt;Externally, Argon is in &lt;a href="https://blog.google/innovation-and-ai/technology/developers-tools/build-with-gemini-4-argon/" rel="noopener noreferrer"&gt;Google Antigravity&lt;/a&gt; for &lt;code&gt;/goal&lt;/code&gt; runs and multi-agent orchestration, in &lt;a href="https://cloud.google.com/blog/products/ai-machine-learning/gemini-4-argon-available-on-google-cloud" rel="noopener noreferrer"&gt;Google Cloud&lt;/a&gt;, and in &lt;a href="https://github.blog/changelog/2026-10-13-gemini-4-argon-in-github-copilot" rel="noopener noreferrer"&gt;GitHub Copilot&lt;/a&gt;. Google says agents working overnight under automated test guardrails cut in-memory session prep time by 40% in long sessions in google/adk-python.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why This Is a Bigger Deal Than It Looks
&lt;/h2&gt;

&lt;p&gt;Start with where Google's table is strong. Argon scores 77.9% on DeepSWE v1.1 against 74.2% for &lt;a href="https://www.anthropic.com/claude/opus" rel="noopener noreferrer"&gt;Claude Opus 5.5&lt;/a&gt; and 74.1% for GPT-6 Astra. On Zapier's AutomationBench it hits 51.3% against 42.5% and 41.4%. On the Vals Index it reaches 68.9%, ahead of Opus 5.5 at 67.0% and Astra at 63.1%, according to &lt;a href="https://prisminfoways.com/blog-single/gemini-4-argon-benchmarks-vs-gpt-6-astra-claude-opus-5-5" rel="noopener noreferrer"&gt;this benchmark roundup&lt;/a&gt;. Its biggest leads are in work shaped like an actual job: finance, legal, long documents and long video.&lt;/p&gt;

&lt;p&gt;Now the other half. Argon scores 55.0% on FrontierSWE v2 against 65.5% for Astra and 62.3% for Opus. On Terminal-Bench 4.0, Opus leads at 66.4% and Argon sits at 57.4%. On &lt;a href="https://artificialanalysis.ai" rel="noopener noreferrer"&gt;Artificial Analysis&lt;/a&gt;, the independent evaluator, &lt;a href="https://parthskills.com/blog/gemini-4-vs-gpt-6-astra-vs-claude-opus/" rel="noopener noreferrer"&gt;Opus 5.5 at max effort scores about 58 while Argon and Astra both land at 53&lt;/a&gt;. The Harvey legal benchmark is a lead worth reading carefully: Argon's 19.6% is the best score, and it is still under 20%.&lt;/p&gt;

&lt;p&gt;The price story is also less clean than it looks. Argon launches at $2 per million input tokens and $10 per million output, against Astra at &lt;a href="https://www.engadget.com/2274263/google-gemini-4-model-argon/" rel="noopener noreferrer"&gt;$10 and $50&lt;/a&gt;. That introductory rate doubles to $4 and $20 later. In &lt;a href="https://blog.sandbase.ai/gemini-4-argon-vs-claude-opus-5-5-vs-gpt-6-astra-2026/" rel="noopener noreferrer"&gt;Sandbase's cost-per-task comparison&lt;/a&gt;, Argon at high effort scores 52.6 for $1.99 a task, while Opus 5.5 at high effort scores 53.6 for $1.82. Argon is clearly cheaper than Astra. Against Opus at comparable effort, the advantage largely disappears.&lt;/p&gt;

&lt;p&gt;One number in Argon's favor deserves its caveat. Its hallucination rate on AA-Omniscience is 15% versus 51% for Astra, but its accuracy is lower, 50% versus 63%, because it declines more often. That is a real tradeoff: fewer confident wrong answers, more "I don't know." For legal and finance agents, many teams will take that deal. For coding agents that need to attempt something, maybe not.&lt;/p&gt;

&lt;p&gt;So no one got dethroned. What changed is that "best model" now depends on the job. Opus leads on composite independent score and terminal work, Astra on the hardest engineering and computer use, and Argon on long-document knowledge work and cost against Astra. For anyone routing workloads across models, that is the more useful outcome than a single winner.&lt;/p&gt;

&lt;h2&gt;
  
  
  Availability and Access
&lt;/h2&gt;

&lt;p&gt;Google announced Argon on September 30 and made it available to developers on October 13. It runs on the paid tier of the Gemini API and in AI Studio, with Antigravity access for Google AI Ultra subscribers and eligible Gemini Enterprise customers. It is excluded from the Gemini API free tier and, for the API, from the Google AI Pro plan, per &lt;a href="https://www.therundown.ai/tools/gemini-4-argon" rel="noopener noreferrer"&gt;The Rundown's access summary&lt;/a&gt;. Pro and Ultra subscribers get it in the &lt;a href="https://blog.google/innovation-and-ai/products/gemini-app/gemini-4-argon-availability/" rel="noopener noreferrer"&gt;Gemini app&lt;/a&gt;, and the cyber-permissive variant stays with Fairwind-approved projects.&lt;/p&gt;

&lt;p&gt;Google did not take the crown, but it did end the idea that one lab owns every leaderboard. The next competitive question is who is best at the specific job you are paying for.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Follow for more coverage on MCP, agentic AI, and AI infrastructure.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>discuss</category>
      <category>gemini</category>
      <category>agents</category>
    </item>
  </channel>
</rss>
