<?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: Piekwerk</title>
    <description>The latest articles on DEV Community by Piekwerk (@piekwerk).</description>
    <link>https://dev.to/piekwerk</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%2F4126175%2F3019591f-2c01-431f-aa32-601b941d91a5.png</url>
      <title>DEV Community: Piekwerk</title>
      <link>https://dev.to/piekwerk</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/piekwerk"/>
    <language>en</language>
    <item>
      <title>Claude Code 2.1.325 asks before sandboxed bash now: 4 changed defaults that stall unattended runs</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Mon, 16 Nov 2026 12:26:57 +0000</pubDate>
      <link>https://dev.to/piekwerk/claude-code-21325-asks-before-sandboxed-bash-now-4-changed-defaults-that-stall-unattended-runs-n7j</link>
      <guid>https://dev.to/piekwerk/claude-code-21325-asks-before-sandboxed-bash-now-4-changed-defaults-that-stall-unattended-runs-n7j</guid>
      <description>&lt;p&gt;Anthropic shipped four Claude Code releases between November 9 and 13, from 2.1.321 through 2.1.325. Coverage went to Code Mode and to Fable 5.2 pricing. The lines that will actually page someone sit in &lt;a href="https://code.claude.com/docs/en/changelog" rel="noopener noreferrer"&gt;2.1.325, dated November 13&lt;/a&gt;: a set of permission defaults moved toward ask-first, and every one of them lands hardest on runs nobody is watching. I read the changelog end to end and cross-checked it against &lt;a href="https://www.frontmatter.fyi/posts/claude-code-2-1-325/" rel="noopener noreferrer"&gt;how the trackers summarized the release&lt;/a&gt;. If you run scheduled tasks, &lt;code&gt;/loop&lt;/code&gt;, or headless &lt;code&gt;claude -p&lt;/code&gt; jobs in CI, four changes concern you directly.&lt;/p&gt;

&lt;h2&gt;
  
  
  The four defaults that moved
&lt;/h2&gt;

&lt;p&gt;Quoting the changelog, compressed but not paraphrased where it matters:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Sandboxed Bash commands now "follow the normal permission flow by default". The old behavior, auto-allow inside the sandbox, lives behind a flag now.&lt;/li&gt;
&lt;li&gt;"Scheduled tasks and &lt;code&gt;/loop&lt;/code&gt; to ask before running a skill that declares &lt;code&gt;allowed-tools&lt;/code&gt; or hooks". An explicit allow rule keeps them unattended.&lt;/li&gt;
&lt;li&gt;"Always allow" in Desktop, IDE and SDK hosts offers a rule "only when saving it would allow that command again", so a scheduled task that relied on one can now wait for you.&lt;/li&gt;
&lt;li&gt;Read-only git commands "ask first in a repository that isn't the project's or one you trusted", and the fix is a flag, not a settings key.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of these come with migration notes. They read like routine changelog lines. Each one converts a silent approval into a prompt, and a prompt in an unattended window is a hang.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sandboxed bash is no longer a silent approval
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"sandbox"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"autoAllowBashIfSandboxed"&lt;/span&gt;&lt;span class="p"&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Before 2.1.325, the deal was simple: the command runs inside the sandbox, so the prompt was skipped. That made the sandbox the fastest way to run CI-style jobs without babysitting. Now the default is the normal flow, ask first, and the flag above is the documented way back.&lt;/p&gt;

&lt;p&gt;Two details from the changelog matter for teams. If managed settings turn the sandbox on, the flag has to sit in your highest-ranking managed source, not in a user settings file, or the prompts come back. And read the setting name for what it is: auto-allow bash if sandboxed. Flipping it back on means trusting the container, so check what your sandbox configuration actually blocks before you do.&lt;/p&gt;

&lt;h2&gt;
  
  
  Scheduled tasks ask before skills that carry hooks
&lt;/h2&gt;

&lt;p&gt;A skill that declares &lt;code&gt;allowed-tools&lt;/code&gt; or hooks can run tools without a per-call prompt; that is the point of the declaration. From 2.1.325, scheduled tasks and &lt;code&gt;/loop&lt;/code&gt; ask before entering such a skill. The explicit opt-out:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"permissions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"allow"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
      &lt;span class="s2"&gt;"Skill(deploy-checks)"&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Naming the skill in &lt;code&gt;permissions.allow&lt;/code&gt; restores the unattended run for that skill only, which is the right shape: you whitelist the skill you reviewed, not all skills forever. If your task runs several skills, each needs its own line, and each line is a small standing decision that someone should be able to explain six months from now.&lt;/p&gt;

&lt;h2&gt;
  
  
  "Always allow" quietly narrowed
&lt;/h2&gt;

&lt;p&gt;In Desktop, IDE and SDK hosts, a rule is offered only when saving it would allow that command again. The changelog states the consequence itself: "a scheduled task that relied on one can now wait for you." The failure mode is annoying because nothing errors. The task pauses on a prompt nobody answers, and you find out later from a stale branch or a missed report. If you maintain unattended hosts, inventory the rules that were saved from interactive sessions and move the ones that matter into settings files under version control, where a scheduled task can actually rely on them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Git in untrusted repos
&lt;/h2&gt;

&lt;p&gt;Read-only git commands now ask first when the repository is not the project's own and not one you trusted. The changelog is specific about the mechanism: name it with &lt;code&gt;--add-dir&lt;/code&gt;, not the &lt;code&gt;additionalDirectories&lt;/code&gt; setting. That distinction does real work. &lt;code&gt;--add-dir&lt;/code&gt; records a trust decision for the session, while a settings key would silently widen what never prompts. For agent workflows that hop between checkouts, this is the change most likely to produce a first-run surprise.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why these shipped together
&lt;/h2&gt;

&lt;p&gt;2.1.325 also fixes "a security issue in how zstd-compressed responses are decoded", and &lt;a href="https://vibecodingweekly.substack.com/p/vibe-coding-weekly-55" rel="noopener noreferrer"&gt;the weekly trackers&lt;/a&gt; counted permission and sandbox fixes across the whole November 9 to 13 run, including read-only commands that ran outside the sandbox without a prompt. The direction is consistent with the rest of the month: fewer silent approvals. We documented &lt;a href="https://dev.to/piekwerk/claude-codes-dont-ask-again-wrote-1379-secrets-into-public-github-files-check-your-repos-before-d16"&gt;1,379 secrets that reached public GitHub files through casually saved don't-ask-again rules&lt;/a&gt;; an allow rule written once, in the wrong context, outlives the reason you wrote it.&lt;/p&gt;

&lt;p&gt;One more hardening line deserves attention: the sandbox now refuses sandboxed writes to &lt;code&gt;.claude&lt;/code&gt; settings, skills, agents, commands and hooks in added directories, as it already did in the launch folder. Your configuration is now protected from the sandboxed process itself. That matters when an agent works in repos that carry MCP servers or plugins you do not fully control, the same exposure we walked through for &lt;a href="https://dev.to/piekwerk/a-repos-gitconfig-could-run-programs-through-mcps-git-server-6-fixes-in-v240-and-4-checks-344g"&gt;MCP's git server fixes in v2.4.0&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Audit before you update
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Search every settings file in play for &lt;code&gt;sandbox&lt;/code&gt; and &lt;code&gt;permissions&lt;/code&gt; keys, and list which of them exist to keep unattended jobs prompt-free.&lt;/li&gt;
&lt;li&gt;List your scheduled tasks and &lt;code&gt;/loop&lt;/code&gt; uses. For each skill they run, check its frontmatter for &lt;code&gt;allowed-tools&lt;/code&gt; or hooks, and add a &lt;code&gt;Skill(name)&lt;/code&gt; allow rule only for the ones you have actually read.&lt;/li&gt;
&lt;li&gt;Inventory "Always allow" rules saved from interactive sessions on hosts that also run unattended work.&lt;/li&gt;
&lt;li&gt;For headless jobs, look at &lt;code&gt;permissions.denyInsteadOfPrompting&lt;/code&gt; from 2.1.319 as well. It is the opposite trade: a call that would prompt gets denied and the turn continues. A stalled run and a denied run both fail the task, but the denied one fails fast and visibly, which is easier to catch in CI. It can also produce a quietly incomplete result, so it belongs on jobs where failure is loud either way.&lt;/li&gt;
&lt;li&gt;Update on a day when someone can watch the first unattended run.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;None of this makes Claude Code harder to use interactively. It makes unattended execution a policy you declare instead of an accident of defaults, and the declarations live in files you can review, diff, and pin. For the rest of the November releases, including the plugin version ranges that now gate installs, see &lt;a href="https://dev.to/piekwerk/claude-code-21323-pins-plugins-to-version-ranges-what-the-engines-field-enforces-and-6-things-to-13bc"&gt;our 2.1.323 breakdown&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>Coding Agent Index v2.1: scores fell 5 points, 4 configs tie at 58, and cost per task spans 30x</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Sun, 15 Nov 2026 19:14:26 +0000</pubDate>
      <link>https://dev.to/piekwerk/coding-agent-index-v21-scores-fell-5-points-4-configs-tie-at-58-and-cost-per-task-spans-30x-1c1c</link>
      <guid>https://dev.to/piekwerk/coding-agent-index-v21-scores-fell-5-points-4-configs-tie-at-58-and-cost-per-task-spans-30x-1c1c</guid>
      <description>&lt;p&gt;On November 14 Artificial Analysis shipped version 2.1 of its &lt;a href="https://artificialanalysis.ai/agents/coding-agents" rel="noopener noreferrer"&gt;Coding Agent Index&lt;/a&gt;, the leaderboard that scores a coding agent as one unit of harness plus model plus effort setting. The short version: nearly everyone lost points, the lead is a four-way tie at 58, and the cost to run one task at the top of the board spans roughly 30x.&lt;/p&gt;

&lt;p&gt;When the index reset in October I wrote about &lt;a href="https://dev.to/piekwerk/20-of-21-agent-configs-just-scored-lower-what-the-coding-agent-index-v20-reset-measures-70j"&gt;what the v2.0 reset measures&lt;/a&gt;. The v2.1 change is narrower but sharper, and the cost column is the part worth your time if you pick models for a coding agent.&lt;/p&gt;

&lt;h2&gt;
  
  
  What v2.1 changed
&lt;/h2&gt;

&lt;p&gt;The index is an equal-weight average of three benchmarks, 322 tasks total, three attempts per task:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Component&lt;/th&gt;
&lt;th&gt;Tasks&lt;/th&gt;
&lt;th&gt;What it measures&lt;/th&gt;
&lt;th&gt;How it scores&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;FrontierCode-AA 2.0&lt;/td&gt;
&lt;td&gt;132&lt;/td&gt;
&lt;td&gt;changes to real open-source repositories&lt;/td&gt;
&lt;td&gt;maintainer-merge rubric, 0 or 70-100%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Terminal-Bench 4.1&lt;/td&gt;
&lt;td&gt;66&lt;/td&gt;
&lt;td&gt;multi-step terminal work&lt;/td&gt;
&lt;td&gt;test suite, pass/fail&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SWE-Atlas-QnA-AA&lt;/td&gt;
&lt;td&gt;124&lt;/td&gt;
&lt;td&gt;repository question answering&lt;/td&gt;
&lt;td&gt;binary pass/fail&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;FrontierCode-AA 2.0 is Artificial Analysis' implementation of &lt;a href="https://cognition.com/blog/frontier-code-2.0" rel="noopener noreferrer"&gt;Cognition's FrontierCode 2.0&lt;/a&gt;, released October 27. An attempt that fails any blocking check scores zero. An attempt that passes them all scores between 70% and 100% depending on non-blocking checks. A trajectory scanner zeroes any attempt that went looking for the upstream solution or its merge commit.&lt;/p&gt;

&lt;p&gt;Terminal-Bench 4.1 keeps 4.0's 66 tasks and environments and replaces the verifiers. Code that runs during grading now runs as an untrusted user in a separate process, and verifiers that rejected valid solutions were corrected. That is reward-hacking hardening, not new tasks.&lt;/p&gt;

&lt;p&gt;The third component and the weighting did not change. The largest component got harder, and that moved the whole board. The full &lt;a href="https://artificialanalysis.ai/methodology/coding-agents-benchmarking" rel="noopener noreferrer"&gt;methodology page&lt;/a&gt; is worth a read.&lt;/p&gt;

&lt;h2&gt;
  
  
  All 23 dual-measured configs lost points on the new FrontierCode
&lt;/h2&gt;

&lt;p&gt;Per the &lt;a href="https://x.com/ArtificialAnlys/status/2121393821955334328" rel="noopener noreferrer"&gt;v2.1 announcement&lt;/a&gt;, index scores came down about 5 points on average, driven by the FrontierCode swap. &lt;a href="https://alphasignal.ai/news/artificial-analysis-frontiercode-2-0-drops-coding-agent-scores-by-16-points" rel="noopener noreferrer"&gt;AlphaSignal's read&lt;/a&gt; of the underlying data is more specific: all 23 configurations evaluated on both versions scored lower on the new FrontierCode, and the mean FrontierCode score fell 16 points, from 45% to 29%.&lt;/p&gt;

&lt;p&gt;That is not the models getting worse. FrontierCode 2.0 pulls from 55% more repositories, carries 43% more blocking criteria per task, and its reference solutions modify 67% more files and 89% more lines in codebases that are 25% larger. The share of thoroughness criteria roughly tripled. Thoroughness criteria catch the patch that fixes the reported case and misses the sibling code path, and Cognition reports thoroughness produced the highest blocker failure rate at every reasoning level they analyzed.&lt;/p&gt;

&lt;p&gt;One configuration barely moved: Codex with GPT-6.1 Terra at max effort stayed within a point of its previous index score. Everyone else ate the reset.&lt;/p&gt;

&lt;p&gt;This is the second consecutive version change that lowered scores across the board. That is the design. A suite that refreshes before vendors tune against it keeps some discriminating power. A score you saw quoted last month is a different exam.&lt;/p&gt;

&lt;h2&gt;
  
  
  The lead at 58 is two models in four configurations
&lt;/h2&gt;

&lt;p&gt;The top score belongs to four configurations, not one product: Claude Code with Fable 5.2 at high effort, Claude Code with Fable 5.2 at xhigh, Claude Code with Opus 5.5 at max, and Devin Fusion CLI with Opus 5.5 Max paired with GPT-6 Luna High.&lt;/p&gt;

&lt;p&gt;Two details matter more than the rank. First, Fable 5.2 at max scores 56, below its own high-effort result, because more of its attempts hit task time limits. Effort is not a simple dial where more is better. Second, Gemini 4 Carbon at high effort scores 55 in Antigravity CLI. The index deliberately scores the harness and the model together, which is why I trust it more than raw model benchmarks for agent work. We have seen this before from the other side: &lt;a href="https://dev.to/piekwerk/hugging-face-measured-it-the-same-model-scores-33-or-62-depending-on-the-harness-1mkk"&gt;Hugging Face measured the same model scoring 33% or 62% depending on the harness&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 30x cost spread is the actionable column
&lt;/h2&gt;

&lt;p&gt;v2.1 also changed how cost is computed. Artificial Analysis aligned it with their Intelligence Index method, combining provider-reported token counts with measured typical cache hit rates. So v2.0-era cost figures you see quoted in older posts are not comparable either.&lt;/p&gt;

&lt;p&gt;Among configurations scoring 48 or above, cost per task runs from $1.51 for Codex with GPT-6.1 Sol at max (index 52) to $44.22 for Claude Code with Fable 5.2 at max (index 56). That is roughly 30x.&lt;/p&gt;

&lt;p&gt;The cheap end of that spread is not a fringe pick. GPT-6.1 Sol is the configuration &lt;a href="https://dev.to/piekwerk/codex-0161-flipped-the-default-model-to-gpt-61-sol-if-you-never-set-model-you-already-switched-577b"&gt;Codex flipped to by default in 0.161&lt;/a&gt;. For a mid-board reference, Artificial Analysis' own &lt;a href="https://artificialanalysis.ai/agents/coding-agents/codex" rel="noopener noreferrer"&gt;Codex page&lt;/a&gt; pegs Codex with GPT-6 Astra at max at 53 index, $7.63 per task on average, and 26.0 minutes per task against a 40.5 minute median.&lt;/p&gt;

&lt;p&gt;So the top of the board asks roughly 29x the per-task cost for 4 index points. Whether that trade is worth it depends entirely on what a task is worth to you, which brings me to the part I actually use.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the spread means for a working week
&lt;/h2&gt;

&lt;p&gt;The arithmetic is blunt:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# per-task API cost at list pricing, AA v2.1 figures
# Codex + GPT-6.1 Sol (max), index 52
40 tasks * $1.51  = $60.40

# Claude Code + Fable 5.2 (max), index 56
40 tasks * $44.22 = $1,768.80
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Three caveats before you take that to a budget meeting. These are benchmark tasks, not your tasks. If you are on a subscription plan, the per-task cost is hidden inside an allowance rather than billed per call. And a 4-point index gap can be a large gap or a rounding error depending on which benchmark components moved, which is exactly why the tie deserves a closer read.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to read the tie without fooling yourself
&lt;/h2&gt;

&lt;p&gt;The index is an equal-weight average of three quite different formats: rubric-graded repository patches, pass/fail terminal work, and pass/fail question answering. Two configurations a couple of points apart can have different strengths, and Artificial Analysis themselves tell you to read the per-benchmark breakdowns rather than the headline.&lt;/p&gt;

&lt;p&gt;A tie at the top means the gap between the leaders is smaller than the evaluation's variance. Treat 58 versus 56 as the same class of thing, not a ranking.&lt;/p&gt;

&lt;p&gt;Cross-version comparisons are category errors. v2.0 to v2.1 changed a component and the cost method, so a vendor graph showing a jump across that boundary is showing the suite change, not the model.&lt;/p&gt;

&lt;p&gt;Finally, safety refusals score zero on every benchmark, so the published blocked rate is the ceiling of what refusals can cost a configuration, and reward-hacking rates are reported per benchmark after integrity review. Those two columns tell you things the headline hides.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I do with this
&lt;/h2&gt;

&lt;p&gt;I pin the harness, model, and effort together as one unit in config, because that is what the index scores and &lt;a href="https://dev.to/piekwerk/model-haiku-stopped-meaning-one-thing-pin-the-exact-model-id-7de"&gt;alias names drift&lt;/a&gt;. For bulk work, many small edits, test runs, dependency bumps, I run the cheap configuration first and escalate only the tasks it fails, and I label that as my own workflow choice rather than a measured result. And when a launch post cites a benchmark jump, the first thing I check is which index version it was scored on. The cheaper question is always your own repo: cost per merged pull request, measured by you, beats any leaderboard.&lt;/p&gt;

&lt;p&gt;Sources: &lt;a href="https://x.com/ArtificialAnlys/status/2121393821955334328" rel="noopener noreferrer"&gt;Artificial Analysis announcement&lt;/a&gt;, &lt;a href="https://artificialanalysis.ai/methodology/coding-agents-benchmarking" rel="noopener noreferrer"&gt;AA methodology&lt;/a&gt;, &lt;a href="https://cognition.com/blog/frontier-code-2.0" rel="noopener noreferrer"&gt;Cognition FrontierCode 2.0&lt;/a&gt;, &lt;a href="https://alphasignal.ai/news/artificial-analysis-frontiercode-2-0-drops-coding-agent-scores-by-16-points" rel="noopener noreferrer"&gt;AlphaSignal analysis&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>Claude Code Projects now talks back: 7 facts about the proactive coordinator, /btw and /fork</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Sun, 15 Nov 2026 09:14:57 +0000</pubDate>
      <link>https://dev.to/piekwerk/claude-code-projects-now-talks-back-7-facts-about-the-proactive-coordinator-btw-and-fork-5h58</link>
      <guid>https://dev.to/piekwerk/claude-code-projects-now-talks-back-7-facts-about-the-proactive-coordinator-btw-and-fork-5h58</guid>
      <description>&lt;p&gt;On November 13 Anthropic's developer account @ClaudeDevs announced "big updates" to &lt;a href="https://news.ycombinator.com/item?id=50492141" rel="noopener noreferrer"&gt;Projects in Claude Code&lt;/a&gt;. Projects is the mode where one coordinator conversation splits your work across parallel threads, and per Anthropic's docs each thread is a full Claude Code cloud session with its own copy of the repository and its own Git branch. The update changes who does the talking: the coordinator now answers your questions in the project chat and posts status updates on running threads without being asked.&lt;/p&gt;

&lt;p&gt;I have not run it yet. The beta is staged and narrow, and my accounts are not in it. What follows is a close read of the announcement thread, its follow-up posts and the docs coverage, because several details change how you would brief a project before you ever get access. The same week the CLI itself shipped &lt;a href="https://dev.to/piekwerk/claude-code-21323-pins-plugins-to-version-ranges-what-the-engines-field-enforces-and-6-things-to-13bc"&gt;plugin version-range pinning&lt;/a&gt;, so the surface is moving fast.&lt;/p&gt;

&lt;h2&gt;
  
  
  What shipped on November 13
&lt;/h2&gt;

&lt;p&gt;Five follow-up posts from @ClaudeDevs listed the additions: the proactive coordinator, /btw and /fork now working inside projects, reminders on threads, read-only sharing links for individual threads, and a recents row with artifact thumbnails in the threads panel. Project settings and local folder access got simpler too. It is a public beta on the paid individual plans (Pro and Max in the announcement, Ultra also listed in the docs), rolling out in stages with a &lt;a href="https://claude.com/form/projects" rel="noopener noreferrer"&gt;waitlist&lt;/a&gt;. Team and Enterprise come later.&lt;/p&gt;

&lt;h2&gt;
  
  
  The coordinator answers in chat, and it reports summaries
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Fact 1.&lt;/strong&gt; The coordinator is now "much more proactive", in Anthropic's words. You can ask the project chat which threads are still running, which pull requests need review and what is blocked, and it reports back. It also posts updates as threads progress instead of waiting to be polled. If you have been babysitting five terminal windows to know what finished, that is the pain this aims at.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fact 2.&lt;/strong&gt; The coordinator reports what its threads tell it. It does not see every internal step of every thread, so status is a summary the threads produce. When a thread goes wrong, the project chat will not show you the failing command or the tool call that returned garbage. You open that thread and read its transcript. The coordinator reduces how often you poll, not how carefully you debug.&lt;/p&gt;

&lt;h2&gt;
  
  
  /btw becomes a worker, /fork becomes a branch
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Fact 3.&lt;/strong&gt; /btw has existed in terminal Claude Code for a while. There it asks a side question and shows the answer in an overlay, and while answering it cannot read files or run commands. Inside Projects it does something bigger: it opens a separate thread that can do real work, and the thread you were in stays on topic.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fact 4.&lt;/strong&gt; In the terminal, /fork copies your whole current session into a background session alongside the original. In Projects it starts a new thread from the one you are in, meant for trying a different approach on the same task. The first thread keeps going. Two attempts at the fix from one brief, and you keep whichever pull request turns out better.&lt;/p&gt;

&lt;p&gt;Anthropic's &lt;a href="https://xiaohu.ai/en/article/claude-code-projects-nov-update/" rel="noopener noreferrer"&gt;demo&lt;/a&gt; runs the exact flow worth internalizing:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# thread: "Upgrade date library"
/btw why is the orders page slow?

# a new thread finds it: the order list looks up each customer
# separately, so a page of 50 orders runs 51 queries (1 list + 50
# customer fetches). It merges them into one query.

# back in that new thread:
/fork try caching instead

# a second thread branches off and adds a short-lived cache for
# customer lookups. Both fixes run side by side, and the
# date-library thread never stops.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That is a context-hygiene primitive. The old failure mode is stuffing the side question into the current session and watching the agent lose the plot.&lt;/p&gt;

&lt;h2&gt;
  
  
  Merge conflicts are the only sync point
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Fact 5.&lt;/strong&gt; Each thread works its own branch of its own repo copy. When two threads touch the same code, the overlap surfaces as an ordinary Git merge conflict in a pull request. There is no resolution layer on top. I find that honest architecture, and it makes your briefing the real concurrency control: split work by repo or module so branches do not collide, and treat any conflict as a planning bug, not a Git problem.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reminders and read-only shares, and one boundary worth keeping
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Fact 6.&lt;/strong&gt; You can set a reminder on any thread, or ask Claude to set one. The thread moves out of the way until the set time, then comes back, and the coordinator raises it in the project chat. For work blocked on a review or an external dependency, the thread stops occupying your attention instead of sitting open as a tab you keep re-reading.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fact 7.&lt;/strong&gt; Any individual thread can be shared as a read-only link to anyone signed in to Claude, from the thread's Share menu. Threads that had access to your computer cannot be shared at all. That boundary is the right call. Transcripts of local sessions can carry file paths, command history and tokens, and we just spent a whole piece on &lt;a href="https://dev.to/piekwerk/cursors-breach-chain-started-in-plain-text-agent-traces-23276-public-repos-carry-the-same-leak-2d42"&gt;how much sensitive material sits in plain-text agent traces&lt;/a&gt;. A share button on those transcripts would be a short path to the same leak.&lt;/p&gt;

&lt;h2&gt;
  
  
  Five threads is five sessions
&lt;/h2&gt;

&lt;p&gt;A new project runs Opus everywhere: worker threads at high effort, the coordinator conversation at low effort, per the docs. Threads draw on the same plan limits as any other Claude Code session, so five parallel workers burn your plan roughly five times faster than one session, and a thread that hits its ceiling pauses and resumes on its own rather than failing loudly. Coverage of the rollout also cites a cap of 200 new threads per day across all projects, though that number comes from AlphaSignal's reporting, not Anthropic's post. Set the model and effort per role before you hand over a big goal, and check the project usage view after the first run.&lt;/p&gt;

&lt;h2&gt;
  
  
  Four rules before you fan out, and what is still missing
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Start with one bounded goal. Migrate one endpoint or profile one page, not the platform.&lt;/li&gt;
&lt;li&gt;Set the dials before starting. You pick the model and effort for the coordinator and the workers separately, plus how often the coordinator checks in. A heavy model on the coordinator plus five workers on the same model is the most expensive default available.&lt;/li&gt;
&lt;li&gt;Brief so branches do not collide. One thread per repo or per module, and any merge conflict means the plan was wrong.&lt;/li&gt;
&lt;li&gt;Read every pull request. A coordinator assembling PRs from five threads is assembling drafts. More threads means more output, not more review capacity.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;What is missing: Projects runs on the web, desktop and mobile apps, not yet in the terminal CLI, the VS Code extension or the JetBrains plugin. Local threads, the version that runs on your own machine, are "coming very soon" per the coverage, which is the piece that matters if your code cannot leave your network.&lt;/p&gt;

&lt;p&gt;The competitive frame is compressing. Cursor shipped its multiplayer Projects three days before this, with shared rules files and task boards rather than a coordinator chat, and &lt;a href="https://dev.to/piekwerk/cursor-projects-goes-multiplayer-5-rules-for-the-shared-agent-context-your-whole-team-inherits-16o8"&gt;I wrote up what that means for shared agent context&lt;/a&gt;. Both products are converging on the same shape: one shared context, many workers, a human at the merge. The differentiator is not the fan-out, everyone can fan out. It is who keeps the context coherent while it happens.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>Cursor's breach chain started in plain-text agent traces: 23,276 public repos carry the same leak</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Sun, 15 Nov 2026 07:10:09 +0000</pubDate>
      <link>https://dev.to/piekwerk/cursors-breach-chain-started-in-plain-text-agent-traces-23276-public-repos-carry-the-same-leak-2d42</link>
      <guid>https://dev.to/piekwerk/cursors-breach-chain-started-in-plain-text-agent-traces-23276-public-repos-carry-the-same-leak-2d42</guid>
      <description>&lt;p&gt;Cursor published its &lt;a href="https://cursor.com/blog/security-incident-update" rel="noopener noreferrer"&gt;final incident report&lt;/a&gt; on November 13, two weeks after a malicious copy of Anthropic's Claude Code extension appeared in its VS Code extension marketplace. I read the whole thing. The interesting part is not the extension. It is the first link in the chain.&lt;/p&gt;

&lt;h2&gt;
  
  
  The chain, in five steps
&lt;/h2&gt;

&lt;p&gt;The report reconstructs the attack like this:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;An attacker obtained an access key Cursor had issued to Fireworks, an inference provider. The key was exposed on Fireworks' side.&lt;/li&gt;
&lt;li&gt;With that key, the attacker copied data from a read-only storage bucket Cursor used to share training data with Fireworks. The bucket held coding agent traces, mostly from 2025, from sessions that were not in Privacy Mode.&lt;/li&gt;
&lt;li&gt;A small number of those traces contained credentials that had not been redacted. Cursor says less than 0.01% of customers had API credentials exposed this way.&lt;/li&gt;
&lt;li&gt;Starting from those credentials, the attacker reached SaaS tools Cursor uses internally, then archived source repositories, support data, email conversations, and some credentials users had sent to the support team.&lt;/li&gt;
&lt;li&gt;On October 29, using a stolen credential from that data, the attacker placed malicious builds of the Claude Code extension directly on the cache that served the marketplace. Open VSX never carried them, and Anthropic published nothing. At most 5,000 users who requested specific cached versions could have received the bad build, which lived for about 11 hours. BleepingComputer &lt;a href="https://www.bleepingcomputer.com/news/security/cursor-confirms-security-breach-led-to-malicious-claude-code-extension/" rel="noopener noreferrer"&gt;reported&lt;/a&gt; the payload installed persistent SSH backdoors.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Read step 3 again. The breach did not start with a zero-day. It started with working credentials sitting in plain text inside stored agent transcripts. Everything after that was climbing. If you run sessions outside Privacy Mode, or you paste a token into a command to unblock an agent at 6pm, you are producing the same artifact class that made step 3 possible.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two numbers worth sitting with
&lt;/h2&gt;

&lt;p&gt;Cursor says traces were exposed for fewer than 0.05% of users, and API credentials for less than 0.01% of customers. Small percentages, and they still yielded enough working credentials to reach internal systems and poison a marketplace cache.&lt;/p&gt;

&lt;p&gt;That is the arithmetic of stored secrets. An attacker does not need a large share of users leaking credentials. One valid key with the right scope is enough. Cursor's own response reads like agreement: the team rotated every credential in use across internal systems, not just the exposed ones, moved all inference traffic off the vendor, and added secret scanning across internal data sources.&lt;/p&gt;

&lt;h2&gt;
  
  
  The same leak, sitting on your disk
&lt;/h2&gt;

&lt;p&gt;Two weeks later, on the file side of the same problem, GitGuardian published a count that dwarfs the numbers Cursor had to contain. Per &lt;a href="https://www.csoonline.com/article/4247336/claude-codes-dont-ask-again-button-has-a-secrets-spilling-problem.html" rel="noopener noreferrer"&gt;CSO Online's report&lt;/a&gt; of the research: 31,088 distinct secrets in &lt;code&gt;.claude/settings.local.json&lt;/code&gt; files across 23,276 public GitHub repositories, with 5,343 of them still valid when detected. Of the occurrences GitGuardian could check, 67% were working credentials.&lt;/p&gt;

&lt;p&gt;I wrote about the mechanism when Apiiro's smaller count came out: approving a command with "Yes, and don't ask again" saves the exact command string, secret included, into a project-level file. &lt;a href="https://dev.to/piekwerk/claude-codes-dont-ask-again-wrote-1379-secrets-into-public-github-files-check-your-repos-before-d16"&gt;That article&lt;/a&gt; covered 1,379 distinct secrets in 1,122 files. Apiiro counted default branches. GitGuardian crawled every public commit back to January 2025 and found twenty times more.&lt;/p&gt;

&lt;p&gt;The pattern holds everywhere agent tooling writes down what happened:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The shared team file, &lt;code&gt;.claude/settings.json&lt;/code&gt;, carried another 8,271 secrets, 1,283 of them valid, in GitGuardian's &lt;a href="https://groundtruth.day/news/claude-code-dont-ask-again-secrets-found-in-23000-public-repositories.html" rel="noopener noreferrer"&gt;tally relayed by Ground Truth&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Public Docker Hub images held 613 distinct secrets in Claude Code settings files across 543 image repositories, because a Dockerfile &lt;code&gt;COPY . .&lt;/code&gt; ignores your &lt;code&gt;.gitignore&lt;/code&gt;. One valid Cloudflare token appeared across 559 image tags.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Why your scanner misses one in five
&lt;/h2&gt;

&lt;p&gt;Apiiro ran gitleaks and TruffleHog, the two most used open-source secret scanners, over all 104,185 public copies of the file. Of the 1,122 files holding a real secret, &lt;a href="https://thehackernews.com/2026/11/claude-codes-dont-ask-again-file.html" rel="noopener noreferrer"&gt;215 were flagged by neither&lt;/a&gt;, close to one in five. The reason is structural. Scanners look for provider formats, a prefix followed by high-entropy string. A password after &lt;code&gt;PGPASSWORD=&lt;/code&gt;, or inside an &lt;code&gt;sshpass&lt;/code&gt; command, is just a word on a command line. Agent artifacts record what ran, not what was sensitive, so the exact place agents write secrets is the place format-based detection covers worst.&lt;/p&gt;

&lt;h2&gt;
  
  
  A rotation order that matches the chain
&lt;/h2&gt;

&lt;p&gt;Order your cleanup by how the attacker actually used the data, not by how easy each step is.&lt;/p&gt;

&lt;p&gt;First, rotate anything you ever pasted into a vendor support chat or ran through a session whose logs you do not control. Cursor's report lists "some credentials users had sent to the Cursor support team" among the exposed data. That class of credential outlives your account with the vendor.&lt;/p&gt;

&lt;p&gt;Second, rotate credentials that reached a committed file, then clean the file. Rotation first, always, because git history and forks keep old copies. Check whether the file was ever committed on any branch:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git log --all --full-history --oneline -- .claude/settings.local.json
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Third, rotate anything baked into a published image. Deleting the file from the repo does not recall published tags; one database password in GitGuardian's data sits in 643 tags across seven image repositories.&lt;/p&gt;

&lt;h2&gt;
  
  
  Five places credentials sit in plain text
&lt;/h2&gt;

&lt;p&gt;Run this audit across all five, in one pass:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Agent traces and transcripts, local session logs included. You are checking for commands that carried a token or password inline.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;.claude/settings.local.json&lt;/code&gt;, the file behind the 23,276 repos.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;.claude/settings.json&lt;/code&gt;, committed on purpose by teams, so it spreads by design.&lt;/li&gt;
&lt;li&gt;Container images, via a &lt;code&gt;COPY . .&lt;/code&gt; that had no &lt;code&gt;.dockerignore&lt;/code&gt; to stop it.&lt;/li&gt;
&lt;li&gt;Support conversations and shared debugging threads.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;A quick pattern probe for the config side:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;grep -rnE &lt;span class="s2"&gt;"(PGPASSWORD=|sshpass|Bearer |AKIA[0-9A-Z]{16}|BEGIN (RSA|OPENSSH) PRIVATE KEY)"&lt;/span&gt; \
  .claude ~/.claude/settings.json 2&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;/dev/null
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It will not catch everything, that is the one-in-five lesson, but it catches the shapes scanners skip.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rules that shrink the vault
&lt;/h2&gt;

&lt;p&gt;Four habits remove most of this surface:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Never approve a secret-bearing command with "don't ask again". Write the allow rule as a pattern without the secret, and pass the secret as an environment variable.&lt;/li&gt;
&lt;li&gt;Add &lt;code&gt;.claude/&lt;/code&gt; and &lt;code&gt;.env*&lt;/code&gt; to &lt;code&gt;.dockerignore&lt;/code&gt; in every image that builds from a repo where agents run:
&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;.claude/
**/.claude/
.env*
**/.env*
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;Treat agent config files as secret-bearing in CI, with pattern checks for command-line secret shapes, not just key-format detectors. I keep &lt;a href="https://dev.to/piekwerk/your-ai-agents-config-files-have-secrets-in-the-clear-a-22-rule-scanner-that-finds-them-3hhl"&gt;a 22-rule scanner&lt;/a&gt; for exactly this class of file.&lt;/li&gt;
&lt;li&gt;Decide about traces the way you decide about screen recordings. If a command would be dangerous to replay in public, it does not belong in any session that logs it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Per Ground Truth's coverage of CSO's reporting, Boris Cherny, who leads Claude Code, said the tool has not done secrets scrubbing and that built-in secret scanning and an auto mode are being explored. Until something ships there, the file-level discipline is on you.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I took from the report
&lt;/h2&gt;

&lt;p&gt;The extension malware was the loud part, and I covered the config-boundary questions when it dropped. The quiet part is that a bucket of 2025 transcripts contained working credentials at all. Your exposure is probably not a marketplace cache. It is the artifacts your own tooling writes on every machine you own, and the copies of those artifacts you never audited. Rotate first, then audit, then write the rules that keep the vault empty.&lt;/p&gt;

&lt;p&gt;If you want the incident timeline and the indicators of compromise, the primary sources are &lt;a href="https://cursor.com/blog/security-incident-update" rel="noopener noreferrer"&gt;Cursor's report&lt;/a&gt; and their October 30 security notice. My earlier piece on &lt;a href="https://dev.to/piekwerk/malware-posed-as-claude-code-in-cursors-marketplace-what-your-agent-config-can-and-cannot-contain-3f61"&gt;what agent configs can and cannot contain&lt;/a&gt; covers the extension side of this event.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>A repo's .git/config could run programs through MCP's git server: 6 fixes in v2.4.0 and 4 checks for your configs</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Sat, 14 Nov 2026 15:10:20 +0000</pubDate>
      <link>https://dev.to/piekwerk/a-repos-gitconfig-could-run-programs-through-mcps-git-server-6-fixes-in-v240-and-4-checks-344g</link>
      <guid>https://dev.to/piekwerk/a-repos-gitconfig-could-run-programs-through-mcps-git-server-6-fixes-in-v240-and-4-checks-344g</guid>
      <description>&lt;p&gt;The reference MCP servers most of us bolt into a client config without a second thought shipped six security fixes on November 11. Three servers are affected: the filesystem server, the git server and the fetch server. One of the six is rated high, and it sits in the git server: a read-only status call against a repository you did not write could run a program named in that repository's own &lt;code&gt;.git/config&lt;/code&gt;, with the privileges of the server process.&lt;/p&gt;

&lt;p&gt;I wrote about the previous security release when it landed on &lt;a href="https://dev.to/piekwerk/mcp-servers-v210-fixes-8-vulnerabilities-filesystem-writes-could-escape-allowed-folders-112h"&gt;October 25 with eight fixes&lt;/a&gt;. Two security releases in under three weeks on the same set of servers says something about how much scrutiny these tools get now, and how much of an agent's real attack surface lives in the server processes you configure, not in the model. The full details are in the &lt;a href="https://github.com/modelcontextprotocol/servers/releases/tag/v2.4.0" rel="noopener noreferrer"&gt;v2.4.0 release notes&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What shipped, and who is exposed
&lt;/h2&gt;

&lt;p&gt;Six advisories across three packages, all published November 11:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Package&lt;/th&gt;
&lt;th&gt;Affected&lt;/th&gt;
&lt;th&gt;Fixed in&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;@modelcontextprotocol/server-filesystem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;all versions before 2.3.0, and date versions 2025.1.14 through 2026.8.31&lt;/td&gt;
&lt;td&gt;2.3.0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;mcp-server-git&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;through 2026.11.4&lt;/td&gt;
&lt;td&gt;2026.11.11&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;mcp-server-fetch&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;through 2026.11.4&lt;/td&gt;
&lt;td&gt;2026.11.11&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The exposure test is simple: if any client config on your machine references one of these three packages, and the version that actually runs is in the affected range, you are exposed. In practice that means a config or lockfile pinned to a date version, a Docker image pulled months ago, or a wrapper script that never gets updated. A bare &lt;code&gt;npx -y&lt;/code&gt; entry with no version resolves the latest release on each launch, so it picks up the fix, at the usual price of running whatever ships next.&lt;/p&gt;

&lt;h2&gt;
  
  
  The high one: a repo's own config could run programs
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;GHSA-6hqx-gqrx-c5r2&lt;/code&gt;, rated high. The mechanism is uncomfortable because it hides behind a read-only tool. &lt;code&gt;mcp-server-git&lt;/code&gt; shells out to git, and git reads the repository's &lt;code&gt;.git/config&lt;/code&gt; before doing anything. Several keys there name programs to run: &lt;code&gt;core.fsmonitor&lt;/code&gt;, &lt;code&gt;diff.external&lt;/code&gt;, hooks, filter and merge drivers, signing. On the old server, a call such as &lt;code&gt;git_status&lt;/code&gt; against an untrusted repository honored those settings, so cloning a repo you found and asking the agent for a status could execute a program the repository's author chose, with the server's privileges.&lt;/p&gt;

&lt;p&gt;The fix overrides those settings on every git command the server runs, and refuses git versions older than 2.31, because those ignore the overrides. That refusal is a behavior change to know about: an environment with an old git now gets a hard error rather than silently losing the protection.&lt;/p&gt;

&lt;h2&gt;
  
  
  The git confinement follow-up
&lt;/h2&gt;

&lt;p&gt;The second git advisory, &lt;code&gt;GHSA-q74p-4wrc-q7w6&lt;/code&gt;, rated medium, completes a fix from October 28. When you start the server with &lt;code&gt;--repository&lt;/code&gt;, that boundary could be escaped three ways: a repository nested inside the allowed one reading another repository's objects through &lt;code&gt;objects/info/alternates&lt;/code&gt;, a linked worktree's Git directory passed off as the allowed repository's, and a symlink inside a Git directory leading outside. All three are refused now. On Windows, a directory junction is not covered yet, tracked as issue #5520.&lt;/p&gt;

&lt;h2&gt;
  
  
  Filesystem: reads could leave the directories you allowed
&lt;/h2&gt;

&lt;p&gt;Two medium advisories here. The first is a check-to-use race: if an allowed directory is swapped for a symlink between the access check and the read, the read tools could return a file from outside the allowed directories. Reads now open the file relative to the directory that was checked, which writes already did, and FIFOs, sockets and devices are refused outright. It is closed on Linux and macOS. On Windows the release notes are blunt: the change "narrows the race without closing it".&lt;/p&gt;

&lt;p&gt;The second, &lt;code&gt;GHSA-7m4x-rv66-mxhh&lt;/code&gt;, is the same class in &lt;code&gt;move_file&lt;/code&gt;. A same-device move first takes the source out of its own checked directory under a fresh name, so a source directory swapped for a symlink can no longer pull an outside file into the allowed directories, where it would become readable.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fetch: two small guard gaps
&lt;/h2&gt;

&lt;p&gt;The fetch server's private-address guard read the deprecated IPv6 site-local range &lt;code&gt;fec0::/10&lt;/code&gt; as public. It is refused now, along with any IPv6 address outside global unicast space (&lt;code&gt;2000::/3&lt;/code&gt;) that does not carry an IPv4 address. Separately, robots.txt rules are matched against the path the site will resolve, not just the path as written, so &lt;code&gt;//private&lt;/code&gt; or &lt;code&gt;/x/../private&lt;/code&gt; no longer gets past &lt;code&gt;Disallow: /private&lt;/code&gt;. Both are rated low. Cheap fixes, worth having if your agent fetches URLs from anywhere you do not control.&lt;/p&gt;

&lt;h2&gt;
  
  
  The npm trap that keeps you on the vulnerable version
&lt;/h2&gt;

&lt;p&gt;This is the part I expect to bite people. The TypeScript servers moved from date versions (2025.x, 2026.x) to semantic versions in 1.0.0. Package managers rank &lt;code&gt;2.3.0&lt;/code&gt; below every &lt;code&gt;2025.x&lt;/code&gt; and &lt;code&gt;2026.x&lt;/code&gt; version, so a lockfile or pin on a date version will never be offered 2.3.0 as an upgrade. To the resolver it looks like a downgrade. The release notes say it directly: install it explicitly.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm install @modelcontextprotocol/server-filesystem@2.3.0
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;For the Python servers, pin the same way, &lt;code&gt;mcp-server-git==2026.11.11&lt;/code&gt; and &lt;code&gt;mcp-server-fetch==2026.11.11&lt;/code&gt; in whatever launches them.&lt;/p&gt;

&lt;p&gt;This is the same lesson as Claude Code's &lt;a href="https://dev.to/piekwerk/claude-code-21323-pins-plugins-to-version-ranges-what-the-engines-field-enforces-and-6-things-to-13bc"&gt;new engines version-range field&lt;/a&gt; and the &lt;a href="https://dev.to/piekwerk/mcp-inspectors-oauth-flow-could-run-powershell-on-windows-inside-cve-2026-119025-and-why-npm-1hei"&gt;MCP Inspector OAuth issue&lt;/a&gt;: version plumbing decides your exposure as much as the code does, and the interesting failures happen where two versioning schemes meet.&lt;/p&gt;

&lt;h2&gt;
  
  
  Four checks I would run today
&lt;/h2&gt;

&lt;p&gt;First, find every config that references the three packages:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;grep -rn &lt;span class="s2"&gt;"server-filesystem\|mcp-server-git\|mcp-server-fetch"&lt;/span&gt; \
  ~/.claude.json ~/.claude/ ~/.cursor/ ~/.codex/ ~/.config/ 2&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;/dev/null
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Second, replace bare or stale entries with explicit pins to the fixed versions, so the resolver has no say in the matter:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"mcpServers"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"filesystem"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nl"&gt;"command"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"npx"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"args"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"-y"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"@modelcontextprotocol/server-filesystem@2.3.0"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"/srv/data"&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="nl"&gt;"git"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nl"&gt;"command"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"uvx"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"args"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"--from"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"mcp-server-git==2026.11.11"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"mcp-server-git"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"--repository"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"/srv/repo"&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Third, Docker users: every server image now runs as its non-root user. A volume owned by root can stop working after the upgrade, and the memory server README gained upgrade steps for exactly that case.&lt;/p&gt;

&lt;p&gt;Fourth, if anything reaches the everything server from another machine, know that its HTTP transports now bind to loopback by default and need &lt;code&gt;HOST&lt;/code&gt; set to widen. A setup that silently stops connecting after this upgrade is probably hitting that line.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is still open after the update
&lt;/h2&gt;

&lt;p&gt;Windows carries two known gaps: the filesystem read race is narrowed, not closed, and git directory junctions are not covered. The git server refuses git older than 2.31 instead of running unprotected, which surfaces old toolchains as errors. None of the six has a CVE id at the time of writing, they are tracked as GitHub security advisories, which matters if your scanner alerts on CVEs only.&lt;/p&gt;

&lt;p&gt;Two smaller changes deserve a look while you are in there. The filesystem server gained &lt;code&gt;--read-only-dir&lt;/code&gt; for per-directory read-only access, which is the clean way to give an agent docs it cannot touch. And the fetch server caps response body size while reading, so one giant response no longer blows up memory.&lt;/p&gt;

&lt;p&gt;If your agents open repositories or directories you did not create, the git fix is the one to act on today. The rest can ride your normal upgrade path, as long as that path actually reaches the fixed versions, and for the filesystem server this release means it will not do that on its own.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>security</category>
      <category>devtools</category>
    </item>
    <item>
      <title>GitHub Next's Ace runs agents with your privileges: 7 facts from its trust model, and 6 checks before you share a channel</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Sat, 14 Nov 2026 10:35:13 +0000</pubDate>
      <link>https://dev.to/piekwerk/github-nexts-ace-runs-agents-with-your-privileges-7-facts-from-its-trust-model-and-6-checks-53hh</link>
      <guid>https://dev.to/piekwerk/github-nexts-ace-runs-agents-with-your-privileges-7-facts-from-its-trust-model-and-6-checks-53hh</guid>
      <description>&lt;p&gt;GitHub Next released &lt;a href="https://github.com/githubnext/ace" rel="noopener noreferrer"&gt;Ace&lt;/a&gt; this week, an open-source collaborative coding environment where people and agents work together in channels that run on your own machines. It is MIT-licensed, it has shipped 98 releases since the repository appeared on October 2, and the README opens with a warning box instead of a feature list. That warning is the most honest paragraph I have read in an agent tool this year, so I worked through the README, the start, usage and command docs, and the architecture file to pin down what the trust model actually says before anyone starts a channel on a shared tailnet.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Ace is, and what you are running
&lt;/h2&gt;

&lt;p&gt;A host process runs on your machine, from source with Bun 1.4 or later, or as the Mac app (Apple silicon, macOS 15 or later). Channels live under &lt;code&gt;$ACE_HOME&lt;/code&gt; on that machine, default &lt;code&gt;~/.local/state/ace&lt;/code&gt;. Each channel is a chat with an agent in it, plus lanes, isolated worktrees the agent starts for parallel work. You need Tailscale running before anything else, and an Anthropic or OpenAI key in Settings → Providers. From a checkout:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;bun install
bun ace new --project ~/code/my-repo
bun ace ask &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;channel&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;"what does this repo do?"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Even solo, a Mac without Tailscale cannot create a channel, because every channel belongs to a tailnet. Models are written &lt;code&gt;provider/id&lt;/code&gt;, for example &lt;code&gt;--model anthropic/claude-opus-5-5&lt;/code&gt;, so pin an exact id rather than a family name, the same lesson as when &lt;a href="https://dev.to/piekwerk/model-haiku-stopped-meaning-one-thing-pin-the-exact-model-id-7de"&gt;model names stopped meaning one thing&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Agents run with your privileges
&lt;/h2&gt;

&lt;p&gt;The warning, verbatim: "Ace runs agents with the privileges of the user running the host. They can execute arbitrary shell commands and read, change, or delete files beyond the project directory." There is no sandbox layer between the agent and your user account, and the next sentence closes the loophole you were hoping for: "Channels and lanes are not security sandboxes." A channel is closer to handing a teammate an SSH session on your machine than to opening a shared document.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lanes isolate work from work, not from you
&lt;/h2&gt;

&lt;p&gt;Each piece of work gets a lane, a copy-on-write worktree, so a new lane starts with its dependencies already in place and parallel agents never share a checkout. That is real isolation for concurrent work: two agents in one repo will not clobber each other's files. It is not a security boundary. The lane's agent still runs as your user and reaches anything your user can reach. Coordinating parallel agents has its own failure modes, Antigravity's &lt;a href="https://dev.to/piekwerk/antigravitys-run-workflow-writes-the-python-that-runs-your-agent-fleet-7-mechanics-the-55go"&gt;/run-workflow&lt;/a&gt; built a whole mechanism around them, but the isolation layer here is the worktree, nothing more.&lt;/p&gt;

&lt;h2&gt;
  
  
  Your tailnet is the entire access control
&lt;/h2&gt;

&lt;p&gt;The README again: "Your tailnet is your team and the sole authority for team membership and collaboration access. Ace has no separate accounts, invitations, or team access controls." Everyone on the tailnet who runs Ace is on your team, with nothing to join. Adding a person means adding them to the tailnet in the Tailscale admin console. The host names each caller with &lt;code&gt;tailscale whois&lt;/code&gt;, so the whole access question reduces to one line: who is on your tailnet, and would you give each of them a shell on this machine?&lt;/p&gt;

&lt;p&gt;GitHub logins sit on top of that, not instead of it. Ace names people by their GitHub login, resolved with &lt;code&gt;gh api user&lt;/code&gt;, and a GitHub-backed project is visible to logins that can read the repository. Local folder projects stay visible only on your own host unless someone shares them, and existing projects became private on upgrade. A share grants the team, or one person, every channel in a project.&lt;/p&gt;

&lt;h2&gt;
  
  
  The two switches that stay off
&lt;/h2&gt;

&lt;p&gt;Two capabilities start off on every new channel, and both are the ones that let other people spend your privileges:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Agent access&lt;/strong&gt;: whether teammates can ask your channel's agent, the one that runs commands as you. Off by default, and turning it on asks first, with the reason stated in the dialog: agents run on your machine with your permissions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Desktop tools&lt;/strong&gt;: whether the channel's agents can operate this Mac's apps. Also off by default.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The CLI forms are explicit, which makes them easy to script and easy to audit:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ace agents fix-login off   &lt;span class="c"&gt;# teammates can read along, not drive the agent&lt;/span&gt;
ace desktop fix-login off  &lt;span class="c"&gt;# agents cannot touch the Mac's apps&lt;/span&gt;
ace project access         &lt;span class="c"&gt;# who can see this project, and why&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Two control planes, one host
&lt;/h2&gt;

&lt;p&gt;The host listens on &lt;code&gt;127.0.0.1:4140&lt;/code&gt;. On loopback, the WebSocket at &lt;code&gt;/ws&lt;/code&gt; needs the owner token from &lt;code&gt;$ACE_HOME/host.token&lt;/code&gt;, sent as a Bearer header. On the tailnet there is no token: Tailscale identifies callers, and the sensitive routes, settings, keys, projects and terminals, are refused there. The same gateway is reachable two ways with two rule sets, and the dangerous operations only work from the machine itself. A host that should never join the team fabric can run &lt;code&gt;ace serve --loopback&lt;/code&gt; and stay off the tailnet and the directory entirely.&lt;/p&gt;

&lt;h2&gt;
  
  
  Everything lands on your disk
&lt;/h2&gt;

&lt;p&gt;Channels live under &lt;code&gt;$ACE_HOME/channels/&amp;lt;id&amp;gt;/&lt;/code&gt;, each holding &lt;code&gt;channel.json&lt;/code&gt; and &lt;code&gt;channel.sqlite&lt;/code&gt;. &lt;code&gt;channel.json&lt;/code&gt; records the tailnet, by MagicDNS suffix, the channel was created on, and the host serves only channels of the tailnet it found at startup; channels from another tailnet stay on disk, hidden. Your provider key sits in the app's settings on that machine. The architecture file also states the deployment model outright: Ace is open source, teams clone and fork it, and "Ace will not operate a hosted service." There is a Beta cloud-compute option that moves an idle channel to a hosted workspace; the agent commits and pushes every lane first, and the channel cannot move back.&lt;/p&gt;

&lt;h2&gt;
  
  
  Six checks before you share a channel
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Treat every channel as a shell for whoever can reach it. The default-off switches help, but tailnet membership is the real decision.&lt;/li&gt;
&lt;li&gt;Keep Ace on a tailnet you control, not the company-wide one that still has ex-employees' devices or shared machines on it.&lt;/li&gt;
&lt;li&gt;Leave agent access and desktop tools off until a task needs them, then turn them off again. One command each, no settings hunt.&lt;/li&gt;
&lt;li&gt;Rotate the provider key if a host ever sat on a tailnet you do not fully control. The key lives in Settings → Providers on that machine.&lt;/li&gt;
&lt;li&gt;Before moving a channel to cloud compute, review what is in the worktrees. Every lane gets committed and pushed, and the move is one-way.&lt;/li&gt;
&lt;li&gt;Read the trust model section of the &lt;a href="https://github.com/githubnext/ace/blob/main/docs/architecture.md" rel="noopener noreferrer"&gt;architecture file&lt;/a&gt; yourself. It is short, and the README calls it binding.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Most agent tools blur the boundary until an incident clarifies it. Ace does the opposite: one wall, named in the first screen of the README, with the two expensive switches off by default. That is the same instinct behind reviewing agent permissions as config instead of ambient magic, whether it is &lt;a href="https://dev.to/piekwerk/mcps-file-transfer-draft-keeps-bytes-out-of-your-models-context-5-mechanics-and-3-open-security-16dd"&gt;the open security questions around MCP's newer primitives&lt;/a&gt; or the allow rules in a coding agent's settings file.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>Antigravity's /run-workflow writes the Python that runs your agent fleet: 7 mechanics, the parallel() failure mode, and when /swarm is the better call</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Sat, 14 Nov 2026 08:27:55 +0000</pubDate>
      <link>https://dev.to/piekwerk/antigravitys-run-workflow-writes-the-python-that-runs-your-agent-fleet-7-mechanics-the-55go</link>
      <guid>https://dev.to/piekwerk/antigravitys-run-workflow-writes-the-python-that-runs-your-agent-fleet-7-mechanics-the-55go</guid>
      <description>&lt;p&gt;Google rolled Dynamic Workflows into Antigravity this week. You type &lt;code&gt;/run-workflow&lt;/code&gt; plus a task, and the agent writes a short Python script that starts other agents for you, in parallel or in sequence, and collects a structured result from each one. The &lt;a href="https://antigravity.google/docs/dynamic-workflows/" rel="noopener noreferrer"&gt;docs are live now&lt;/a&gt;, and the feature is available on Google AI Pro and Ultra plans in both the Antigravity App and the CLI.&lt;/p&gt;

&lt;p&gt;I read the full documentation page before writing this, and most of it is a calm description of primitives. The interesting parts are what the design implies about context, permissions, and failure handling. Here is what stood out.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the agent actually writes
&lt;/h2&gt;

&lt;p&gt;When you run &lt;code&gt;/run-workflow&lt;/code&gt;, the agent reads its built-in run-workflow skill and generates a Python script for your task. Antigravity shows you the script and asks you to approve it, unless your permission preset already allows it. The workflow then runs in the background in a separate Python process, and when it finishes, the main agent reads the logs and output, then summarizes the results in your conversation.&lt;/p&gt;

&lt;p&gt;The example script in the docs is short enough to read in full:&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="nf"&gt;phase&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Discover"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;files&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s2"&gt;"List the Python files changed since main. Paths only."&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;schema&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"array"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"items"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&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="nf"&gt;phase&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Review"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;reviews&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;parallel&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;files&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;agent&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;"Review {f} for unhandled exceptions. Reply with a one-line verdict."&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;schema&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;role&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"Review {f}"&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;"flash"&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="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;reviews&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Every agent gets its own conversation
&lt;/h2&gt;

&lt;p&gt;Each agent a workflow starts works in its own conversation. File reads, searches, and test logs stay out of your main conversation's context. That is the quiet headline of this release: fan-out work stops paying the context tax on the thread you are actually sitting in.&lt;/p&gt;

&lt;p&gt;Results come back through a &lt;code&gt;finish&lt;/code&gt; tool that checks each agent's answer against the JSON Schema you passed to &lt;code&gt;agent()&lt;/code&gt;. The script receives a parsed value, not prose you regex apart. If you have been following the &lt;a href="https://dev.to/piekwerk/mcps-file-transfer-draft-keeps-bytes-out-of-your-models-context-5-mechanics-and-3-open-security-16dd"&gt;MCP file transfer draft&lt;/a&gt;, this is the same instinct applied to orchestration: keep the bulk bytes out of the model's way, hand around small validated summaries instead.&lt;/p&gt;

&lt;h2&gt;
  
  
  Agents cannot see the script or each other
&lt;/h2&gt;

&lt;p&gt;Workflow agents are full agents, but they do not see the orchestration script and they do not see each other. The docs state the consequence plainly: the script must give each agent everything it needs in its prompt and ask for a short, well-defined result.&lt;/p&gt;

&lt;p&gt;If your reviewers need the coding standard, the script pastes it in or names the file. Implicit context does not travel. This is the same discipline as keeping a tight AGENTS.md or CLAUDE.md, applied per agent instead of per repo, and it is why stale instructions hurt so much: &lt;a href="https://dev.to/piekwerk/stale-todos-are-instructions-your-agent-obeys-google-measured-77-more-tokens-24m7"&gt;your agent obeys whatever is written down&lt;/a&gt;, and in a workflow nothing else exists.&lt;/p&gt;

&lt;h2&gt;
  
  
  The primitives, and the parallel() failure mode
&lt;/h2&gt;

&lt;p&gt;The building blocks are &lt;code&gt;phase(name)&lt;/code&gt; for grouping, &lt;code&gt;log()&lt;/code&gt; for output lines, &lt;code&gt;agent()&lt;/code&gt; for one-shot or multi-turn agents, &lt;code&gt;parallel(items, fn)&lt;/code&gt; for concurrency, &lt;code&gt;pipeline(items, fn)&lt;/code&gt; for one-at-a-time ordering, and &lt;code&gt;await trajectory()&lt;/code&gt; to read earlier steps of the conversation that existed before the workflow started. There is also an &lt;code&gt;args&lt;/code&gt; dictionary for runtime inputs.&lt;/p&gt;

&lt;p&gt;The one sentence worth memorizing is about &lt;code&gt;parallel()&lt;/code&gt;: if one item fails, the others are canceled. On a 40-file review where one agent trips, the 39 in-flight results die with it. The docs describe no retry and no partial-result mode for that case, so treat a failed item as a whole-phase retry, keep phases small, and reach for &lt;code&gt;pipeline()&lt;/code&gt; when ordering matters more than speed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Model, workspace, and agent type knobs
&lt;/h2&gt;

&lt;p&gt;Three settings do most of the work. &lt;code&gt;model&lt;/code&gt; defaults to &lt;code&gt;inherit&lt;/code&gt;, and the docs suggest &lt;code&gt;flash_lite&lt;/code&gt; or &lt;code&gt;flash&lt;/code&gt; for fast, high-volume checks across many files, or &lt;code&gt;pro&lt;/code&gt; for deeper reasoning. &lt;code&gt;workspace&lt;/code&gt; can be &lt;code&gt;inherit&lt;/code&gt;, &lt;code&gt;branch&lt;/code&gt; for an isolated Git worktree per agent (the right call when agents edit code in parallel), or &lt;code&gt;share&lt;/code&gt; for working copies over shared repository storage. &lt;code&gt;type_name&lt;/code&gt; picks the agent type: &lt;code&gt;self&lt;/code&gt;, the built-in read-only &lt;code&gt;research&lt;/code&gt; agent, or one of your custom subagents.&lt;/p&gt;

&lt;p&gt;Multi-turn agents are the subtle one. Assign &lt;code&gt;a = agent(...)&lt;/code&gt;, then &lt;code&gt;await a(prompt)&lt;/code&gt; runs one turn of a conversation that persists across calls, so the reviewer that found the bugs can later be asked to confirm the fixes, with its earlier context intact.&lt;/p&gt;

&lt;h2&gt;
  
  
  Permissions have two layers
&lt;/h2&gt;

&lt;p&gt;Approving the script is one approval, and the docs note that it covers that exact script: a command prefix rule cannot cover a Python script. The second layer is per agent. Every agent a workflow starts follows your permission preset and asks for approval in its own conversation, and it waits until you answer.&lt;/p&gt;

&lt;p&gt;So approving the script does not pre-approve what its agents later do. That split is honest, and it also means an unattended preset delegates both layers at once. Worth knowing before you fan out twenty agents with write access.&lt;/p&gt;

&lt;h2&gt;
  
  
  When /swarm or Orchestrator is the better call
&lt;/h2&gt;

&lt;p&gt;The docs include a comparison table, and the boundaries are useful. &lt;a href="https://dev.to/piekwerk/antigravity-now-switches-models-mid-session-for-you-24-less-quota-a-new-default-model-and-a-457a"&gt;Orchestrator&lt;/a&gt; is a single conversation where a planner model routes execution to a lighter model. Subagents are for delegating one task while you keep working. Dynamic Workflows are for predictable, scripted control flow: the same check across a list of files or packages, staged steps in sequence, a reviewer-and-fixer loop where agents return structured results to a script instead of talking to each other.&lt;/p&gt;

&lt;p&gt;If your agents need to coordinate while they work, to agree on interfaces or review each other's diffs on a shared message board, that is &lt;code&gt;/swarm&lt;/code&gt; territory. A workflow script cannot express peer coordination, because the agents cannot hear each other.&lt;/p&gt;

&lt;h2&gt;
  
  
  Practical notes for running it
&lt;/h2&gt;

&lt;p&gt;Antigravity bundles its own Python, unpacked on the first workflow run, so there is nothing to install. To use a different interpreter, set &lt;code&gt;ANTIGRAVITY_PYTHON&lt;/code&gt; to a Python 3.8 or later on your PATH; if it cannot start, the workflow stops with an error naming the variable. Ask the agent to save a script that works into your project, and it becomes a rerunnable, reviewable artifact sitting next to the code it operates on, which beats a chat transcript you can never quite reproduce.&lt;/p&gt;

&lt;p&gt;Two closing cautions. A workflow that starts one agent per file is, by construction, many model calls, so the per-agent model choice is where your cost control lives. And if you used the legacy Workflows feature, it is deprecated, with &lt;code&gt;/migrate-workflows&lt;/code&gt; in the App 2.12.0 or later to move it forward.&lt;/p&gt;

&lt;p&gt;The shape of this is what I find most interesting: orchestration as generated, inspectable code, with schema-shaped results and isolated contexts. That is a far cleaner contract than hoping a room full of agents talks nicely.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devtools</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Antigravity now switches models mid-session for you: 24% less quota, a new default model, and a 45-day retirement clock</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Fri, 13 Nov 2026 17:49:15 +0000</pubDate>
      <link>https://dev.to/piekwerk/antigravity-now-switches-models-mid-session-for-you-24-less-quota-a-new-default-model-and-a-457a</link>
      <guid>https://dev.to/piekwerk/antigravity-now-switches-models-mid-session-for-you-24-less-quota-a-new-default-model-and-a-457a</guid>
      <description>&lt;p&gt;Google shipped two connected things this week, and the quiet one changes your config more than the loud one. The loud one is &lt;a href="https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-hydrogen/" rel="noopener noreferrer"&gt;Gemini 4 Hydrogen&lt;/a&gt;, a fast execution model announced November 12. The quiet one is Orchestrator, arriving in Antigravity, which switches between models mid-session instead of running one model from start to finish. One session, two models, picked per task by the harness.&lt;/p&gt;

&lt;p&gt;I read the announcement post, the &lt;a href="https://aistudio.google.com/docs/whats-new-gemini-4-hydrogen" rel="noopener noreferrer"&gt;AI Studio model docs&lt;/a&gt;, and the early coverage from &lt;a href="https://www.infoworld.com/article/4248403/google-adds-multi-model-orchestrator-gemini-4-hydrogen-to-antigravity.html" rel="noopener noreferrer"&gt;InfoWorld&lt;/a&gt; and &lt;a href="https://venturebeat.com/technology/google-launches-gemini-4-hydrogen-a-faster-smarter-pricier-flash-successor" rel="noopener noreferrer"&gt;VentureBeat&lt;/a&gt;. Here is what switched, what it saves on Google's own benchmarks, and the two catches buried in the documentation.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Orchestrator actually does
&lt;/h2&gt;

&lt;p&gt;Orchestrator dynamically switches between models like Carbon and Hydrogen within the same session. That is Google's own description. InfoWorld's writeup spells out the split: a planner model, either Gemini 4 Carbon or Argon, explores the codebase, identifies dependencies, and develops an implementation plan. Hydrogen then handles execution: editing files, writing code, and running builds and tests.&lt;/p&gt;

&lt;p&gt;Google's numbers, published in the announcement: on Terminal-Bench 4.1, Orchestrator reached near-Carbon task success rates while consuming on average 24 percent less quota and completing 19 percent faster. For parallel work, Carbon acts as the coordinator while Hydrogen powers worker and verifier agents building and testing changes across isolated workspaces.&lt;/p&gt;

&lt;p&gt;The point is not that Hydrogen outthinks Carbon. It is that most turns in a coding session never needed frontier reasoning, and the harness now makes that call per task instead of you making it per session.&lt;/p&gt;

&lt;h2&gt;
  
  
  Hydrogen alone: fast for its class, honestly ranked
&lt;/h2&gt;

&lt;p&gt;Standalone, Hydrogen fills the 3.8 Flash slot. On the Artificial Analysis Intelligence Index it scores 51 at its default high thinking level, one point ahead of Argon's 50, and 54 at the new xhigh level. Google says it finishes tasks 2.5 times faster than 3.8 Flash at the default setting, cuts fabricated claims by more than 5x, and more than triples the Terminal-Bench 4.1 score (57 percent versus 18.2 for Flash).&lt;/p&gt;

&lt;p&gt;Two honest caveats: the speed and benchmark numbers are Google's own, measured against Google's previous models rather than an independent lab, and "near-Carbon" success at 24 percent less quota is an average across their benchmark tasks, not a promise about your repo.&lt;/p&gt;

&lt;p&gt;Pricing is flat across the entire 1 million token context window: $1.50 per million input tokens and $7.50 per million output tokens, thinking tokens included. Cached input drops to $0.075 per million, a 95 percent implicit caching discount. The unified window is real, though: input, thinking, and output all draw from the same 1,048,576 tokens. On the API it sits on the free tier, and in Antigravity it requires a paid Google AI Pro or Ultra subscription.&lt;/p&gt;

&lt;h2&gt;
  
  
  Your default model moved, again
&lt;/h2&gt;

&lt;p&gt;Buried in the AI Studio docs, one line: "The Antigravity agent now uses Gemini 4 Hydrogen (&lt;code&gt;gemini-4-hydrogen&lt;/code&gt;) by default."&lt;/p&gt;

&lt;p&gt;If you had sessions, snapshots, or cost estimates built on the previous default, they just moved. This is the same class of change Claude Code users hit when &lt;a href="https://dev.to/piekwerk/fable-52-is-claude-codes-new-default-fable-1m-context-840-and-your-saved-51-pick-just-moved-54g6"&gt;Fable 5.2 became the default&lt;/a&gt; and saved picks shifted underneath them. Auto-updating defaults are convenient until you are trying to reproduce last month's bill or benchmark.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 45-day retirement clock
&lt;/h2&gt;

&lt;p&gt;Here is the catch that matters most for anyone writing configs. The &lt;a href="https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/guides/gemini-4-hydrogen" rel="noopener noreferrer"&gt;Google Cloud docs&lt;/a&gt; list Hydrogen as a short-term GA release, subject to a minimum 45-day retirement notice policy.&lt;/p&gt;

&lt;p&gt;Read that against your own setup. If &lt;code&gt;gemini-4-hydrogen&lt;/code&gt; is baked into agent configs, CI variables, docs, or scripts, retirement arrives on as little as 45 days of notice. Aliases drift silently, exact IDs die loudly. I wrote about this when &lt;a href="https://dev.to/piekwerk/model-haiku-stopped-meaning-one-thing-pin-the-exact-model-id-7de"&gt;"haiku" stopped meaning one thing&lt;/a&gt; across providers: pin what you can verify, and record what each ID was pinned for. A model that can vanish in 45 days is exactly the thing your config should treat as a version, not a constant.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rolling the same routing yourself
&lt;/h2&gt;

&lt;p&gt;You do not need Antigravity to run planner/executor routing. The AI Studio docs describe switching models across turns in one multi-turn session on the Interactions API, using &lt;code&gt;previous_interaction_id&lt;/code&gt;: route planning turns to Carbon and execution turns to Hydrogen, preserving state between them. Hydrogen also supports 65,536-token hops on both streaming and non-streaming requests, double the 32,768 per non-streaming REST hop on Carbon and Argon, which matters in long execution loops.&lt;/p&gt;

&lt;p&gt;The routing decision, sketched as config (my illustration, not Antigravity's format):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"routing"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"plan"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;    &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"model"&lt;/span&gt;&lt;span class="p"&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="nl"&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="nl"&gt;"execute"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"model"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"gemini-4-hydrogen"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&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="nl"&gt;"verify"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;  &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"model"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"gemini-4-hydrogen"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"thinking_level"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"medium"&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Hydrogen's four thinking levels (low, medium, high as default, and the new xhigh) give you an effort dial inside each stage, the same shift GitHub made when &lt;a href="https://dev.to/piekwerk/copilot-fusion-is-ga-2-points-off-opus-55-max-at-half-the-cost-and-your-model-picker-is-now-an-4dh1"&gt;Copilot's model picker became an effort selector&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The catch nobody logs for: attribution
&lt;/h2&gt;

&lt;p&gt;When the harness picks the model, your records need to say which one ran. An analyst quoted in InfoWorld's coverage put it directly: "CIOs need visibility into which model made a particular decision or code change. Without model-level logs and clear attribution, enterprises could find it difficult to audit AI-generated code, investigate errors, establish accountability when something goes wrong."&lt;/p&gt;

&lt;p&gt;The savings from routing are real. So is the cost of losing per-turn model attribution. If your observability pipeline logs token counts but not model IDs per turn, this feature quietly breaks your audit trail.&lt;/p&gt;

&lt;p&gt;One more math item: Google's own pricing docs move Carbon and Argon from introductory $2/$10 pricing to $4/$20 on December 1, while Hydrogen stays at $1.50/$7.50. Any routing policy you write this week has a different cost curve on December 1. Re-run the arithmetic after the switch.&lt;/p&gt;

&lt;h2&gt;
  
  
  Four checks for this week
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Grep your configs and CI variables for &lt;code&gt;gemini-&lt;/code&gt; model IDs. Every exact ID pointing at a short-term release needs a retirement plan, not a shrug.&lt;/li&gt;
&lt;li&gt;Check your Antigravity default. If it moved to Hydrogen under you, update cost estimates and any saved comparison baselines.&lt;/li&gt;
&lt;li&gt;If you route models yourself, record the model ID and thinking level per turn in your logs, not just token counts.&lt;/li&gt;
&lt;li&gt;After December 1, redo the planner/executor cost math with Carbon at $4/$20 and see whether Argon or a Hydrogen-heavy split wins.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The direction is clear either way: the model field in your agent config is becoming a routing table. Google just made that literal in one IDE.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devtools</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Claude Code 2.1.323 pins plugins to version ranges: what the engines field enforces and 6 things to check</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Fri, 13 Nov 2026 06:54:17 +0000</pubDate>
      <link>https://dev.to/piekwerk/claude-code-21323-pins-plugins-to-version-ranges-what-the-engines-field-enforces-and-6-things-to-13bc</link>
      <guid>https://dev.to/piekwerk/claude-code-21323-pins-plugins-to-version-ranges-what-the-engines-field-enforces-and-6-things-to-13bc</guid>
      <description>&lt;p&gt;Anthropic shipped Claude Code 2.1.323 on November 12. By one third-party count it bundles 294 changes, and 20 of them are breaking changes or deprecations (&lt;a href="https://dev.classmethod.jp/en/articles/20261113-cc-updates-v2-1-323/" rel="noopener noreferrer"&gt;DevelopersIO counted them&lt;/a&gt;). The headline everyone will quote is Code Mode, where Claude writes JavaScript to call its tools. If you maintain plugins, marketplaces, or permission rules, the quieter items matter more. I read the &lt;a href="https://code.claude.com/docs/en/changelog" rel="noopener noreferrer"&gt;full changelog&lt;/a&gt; end to end and checked the doc pages it points at. Here is what actually changes for your config.&lt;/p&gt;

&lt;h2&gt;
  
  
  Plugins now carry a version range
&lt;/h2&gt;

&lt;p&gt;The changelog adds &lt;code&gt;engines["claude-code"]&lt;/code&gt; to &lt;code&gt;plugin.json&lt;/code&gt;. The stated behavior: plugins outside their declared Claude Code version range are not installed, not updated, and not loaded, and install plus update pick the newest plugin version that fits.&lt;/p&gt;

&lt;p&gt;This is npm's &lt;code&gt;package.json&lt;/code&gt; &lt;code&gt;engines&lt;/code&gt; field, applied to agent tooling. If your plugin's hooks lean on CLI internals (hook event names, tool schemas, the permission check flow), you can now declare the range you actually tested, and Claude Code enforces it instead of letting your plugin load into a CLI that silently broke it.&lt;/p&gt;

&lt;p&gt;The shape, per the field name in the changelog:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"my-team-plugin"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"version"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"1.4.0"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"engines"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"claude-code"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&amp;gt;=2.1.323 &amp;lt;2.2.0"&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One honest caveat: that range syntax is my illustration, modeled on npm. The &lt;a href="https://code.claude.com/docs/en/plugins/manifest-reference" rel="noopener noreferrer"&gt;plugin manifest reference&lt;/a&gt; does not document the field yet. I fetched that page today (November 13) and it contains zero mentions of &lt;code&gt;engines&lt;/code&gt;. The changelog line is the entire public spec right now, so verify the accepted syntax there before you publish a marketplace entry.&lt;/p&gt;

&lt;h2&gt;
  
  
  Code Mode is opt-in, and its doc page 404s
&lt;/h2&gt;

&lt;p&gt;Code Mode lets Claude write JavaScript to compose its tool calls instead of emitting them one at a time. It is experimental and opt-in, and the changelog says you can turn it off for an organization.&lt;/p&gt;

&lt;p&gt;The changelog links a doc page for turning it on and off. That page returned a 404 when I checked it today. If your org policy is "no undocumented experimental modes", there is no public doc to point at yet. The better reason to wait: how Code Mode interacts with permission rules is not written down anywhere. When tool calls get composed inside generated JavaScript, what your allow rules actually gate can change shape. Keep it off until the docs exist, then re-read your rules.&lt;/p&gt;

&lt;h2&gt;
  
  
  Permission defaults moved, in the right direction
&lt;/h2&gt;

&lt;p&gt;Three changes tighten what your permission files mean.&lt;/p&gt;

&lt;p&gt;First, startup now warns about Bash allow rules with a &lt;code&gt;*&lt;/code&gt; inside a variable's value, such as &lt;code&gt;Bash(PORT=* npm run dev)&lt;/code&gt;. A wildcard in the middle of an allow rule is a common accidental over-grant, and now the CLI names it at startup.&lt;/p&gt;

&lt;p&gt;Second, "don't ask again" got a memory limit. An allow rule that looks like it holds a secret, or that would be saved into a git-tracked &lt;code&gt;settings.local.json&lt;/code&gt;, now lasts for the session only and is not written to disk. This descends directly from the Apiiro census that found 1,122 public repos holding real secrets inside tracked settings files. I covered that census and the remediation angle &lt;a href="https://dev.to/piekwerk/claude-codes-dont-ask-again-wrote-1379-secrets-into-public-github-files-check-your-repos-before-d16"&gt;last week&lt;/a&gt;; this change closes the write path that produced those files.&lt;/p&gt;

&lt;p&gt;Third, hook answers no longer outrank failing checks. If a permission check errors after a &lt;code&gt;PreToolUse&lt;/code&gt; hook returned "allow", Claude Code now decides the call as if no hook had answered. A &lt;code&gt;PermissionRequest&lt;/code&gt; hook that rewrote input which then fails its check gets asked again, or refused where nobody can answer. Belt and suspenders now both have to pass.&lt;/p&gt;

&lt;h2&gt;
  
  
  Git hooks lost their tokens
&lt;/h2&gt;

&lt;p&gt;Claude Code's internal ripgrep and most of its internal git commands now run without most of its sign-in tokens and API keys. A credential helper or hook running under one of those git commands no longer finds them.&lt;/p&gt;

&lt;p&gt;That is a real security win: a hook planted under a git command cannot exfiltrate tokens it cannot read. The flip side is silent breakage. If your setup relied on a git credential helper seeing Claude Code's tokens, it stopped working without an error that names the cause. Audit any custom git hooks that run inside sessions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Unknown models now assume 1M context
&lt;/h2&gt;

&lt;p&gt;The context window assumed for a model ID Claude Code does not recognize went from 200K to 1M. On vendors' models with a smaller real window, a full session can now fail every turn until &lt;code&gt;/clear&lt;/code&gt;, because the CLI keeps feeding context the model cannot hold. &lt;code&gt;CLAUDE_CODE_DISABLE_1M_CONTEXT=1&lt;/code&gt; restores the 200K assumption.&lt;/p&gt;

&lt;p&gt;This lands hardest behind LLM gateways, where model IDs are custom or proxied and therefore unrecognized. Same audience affected by the 2.1.319 auto-mode change, which also hit gateway users hardest. Set the env var before you need it, not after a week of mystery failures.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP sign-ins and supply-chain checks
&lt;/h2&gt;

&lt;p&gt;Two smaller tightenings.&lt;/p&gt;

&lt;p&gt;The MCP server sign-in flow now asks you to confirm before finishing, even in bypass and auto modes. Where nobody can be asked (headless &lt;code&gt;dontAsk&lt;/code&gt; runs), complete it manually with &lt;code&gt;/mcp&lt;/code&gt;. Project-level &lt;code&gt;.mcp.json&lt;/code&gt; approvals must also match the server's exact name now, and an approval written in a different spelling asks again. Check your &lt;code&gt;.mcp.json&lt;/code&gt; spellings if a server that used to be pre-approved starts prompting.&lt;/p&gt;

&lt;p&gt;Plugin and marketplace installs also fail when a git submodule is not on the commit its repository records. That is a supply-chain gate, and a welcome one after &lt;a href="https://dev.to/piekwerk/malware-posed-as-claude-code-in-cursors-marketplace-what-your-agent-config-can-and-cannot-contain-3f61"&gt;malware posed as a Claude Code plugin&lt;/a&gt; in a third-party marketplace last month.&lt;/p&gt;

&lt;h2&gt;
  
  
  Startup fails closed on bad sandbox settings
&lt;/h2&gt;

&lt;p&gt;A &lt;code&gt;--settings&lt;/code&gt; file that is not valid JSON and contains a sandbox key now stops startup outright, even when the key turns the sandbox off. The failure default is the safe one: an unparseable sandbox config used to be a gamble, now it is a halt. Claude Code &lt;a href="https://dev.to/piekwerk/claude-code-21317-tightens-failure-defaults-sdk-hook-callbacks-can-block-and-an-email-leak-now-768"&gt;tightened failure defaults before&lt;/a&gt;, in 2.1.317, and the direction is consistent.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to check this week
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;grep -rn &lt;span class="s1"&gt;'Bash('&lt;/span&gt; .claude/settings.json .claude/settings.local.json &lt;span class="o"&gt;|&lt;/span&gt; grep &lt;span class="s1"&gt;'\*'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ol&gt;
&lt;li&gt;Run that grep and rewrite any wildcard-in-variable allow rules it finds.&lt;/li&gt;
&lt;li&gt;If you maintain a plugin, decide your &lt;code&gt;engines["claude-code"]&lt;/code&gt; range now, and run &lt;code&gt;claude plugin validate --strict&lt;/code&gt;, which now type-checks TypeScript hooks and fails on findings under &lt;code&gt;--strict&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Re-test any git credential helper that depended on Claude Code's tokens.&lt;/li&gt;
&lt;li&gt;Behind a gateway with custom model IDs, set &lt;code&gt;CLAUDE_CODE_DISABLE_1M_CONTEXT=1&lt;/code&gt; if the real window is under 1M.&lt;/li&gt;
&lt;li&gt;Verify &lt;code&gt;.mcp.json&lt;/code&gt; server names match installed servers exactly.&lt;/li&gt;
&lt;li&gt;Leave Code Mode off until its doc page resolves.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The through-line of this release: the config surface is becoming enforced instead of advisory. Version ranges get enforced at install time, secret-looking rules stop persisting, hooks stop overriding failing checks, and unparseable sandbox settings stop sessions. If you treat agent config as infrastructure, this release does part of your governance work for you.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claude</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>Claude Code's don't-ask-again wrote 1,379 secrets into public GitHub files: check your repos before you write another allow rule</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Thu, 12 Nov 2026 16:25:04 +0000</pubDate>
      <link>https://dev.to/piekwerk/claude-codes-dont-ask-again-wrote-1379-secrets-into-public-github-files-check-your-repos-before-d16</link>
      <guid>https://dev.to/piekwerk/claude-codes-dont-ask-again-wrote-1379-secrets-into-public-github-files-check-your-repos-before-d16</guid>
      <description>&lt;p&gt;Security firm &lt;a href="https://thehackernews.com/2026/11/claude-codes-dont-ask-again-file.html" rel="noopener noreferrer"&gt;Apiiro published research on November 5&lt;/a&gt; that made me open every project I own and grep for one file. They found 104,185 public copies of &lt;code&gt;.claude/settings.local.json&lt;/code&gt; on GitHub, and 1,122 of them hold at least one real secret, 1,379 distinct credentials in current copies alone. Count git history, shared settings files, and saved agent transcripts, and the total reaches 2,539 secrets across 1,994 repositories. The file is written by a button most of us click without thinking: "Yes, and don't ask again."&lt;/p&gt;

&lt;h2&gt;
  
  
  The mechanism, exactly
&lt;/h2&gt;

&lt;p&gt;When Claude Code wants to run a shell command, it asks for permission. If you pick "don't ask again", the approval is saved as an allow rule in &lt;code&gt;.claude/settings.local.json&lt;/code&gt; in the project folder. The problem is what the rule contains: the rule is the command string itself, verbatim.&lt;/p&gt;

&lt;p&gt;So when the agent proposes something like this, because that is what the migration actually needs:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nv"&gt;PGPASSWORD&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;hunter2 psql -h db.staging.example.com -U app -d shop -f migrate.sql
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;and you click "don't ask again", the file ends up with:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"permissions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"allow"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
      &lt;span class="s2"&gt;"Bash(PGPASSWORD=hunter2 psql -h db.staging.example.com -U app -d shop -f migrate.sql)"&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The password is now in a plain JSON file inside your repo tree. Of the secrets Apiiro classified, more than a third open a database directly: 379 database passwords and 122 Supabase service role keys.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the leak travels
&lt;/h2&gt;

&lt;p&gt;Claude Code does try to keep the file out of git. The first time it writes the file inside a git repository, it adds &lt;code&gt;**/.claude/settings.local.json&lt;/code&gt; to your global git excludes. But that protection lives in one user's git config on one machine. It never touches the repository's own &lt;code&gt;.gitignore&lt;/code&gt;, so it does not travel with the project.&lt;/p&gt;

&lt;p&gt;Clone the repo on a new laptop, or &lt;code&gt;git init&lt;/code&gt; a folder that already contains the file, and nothing protects you. Apiiro also reports Claude Code itself sometimes commits the file without the user asking. And deleting the file changes nothing about exposure: old versions stay in git history, and history is in every fork and clone.&lt;/p&gt;

&lt;h2&gt;
  
  
  The part that surprised me most: scanners miss it
&lt;/h2&gt;

&lt;p&gt;Apiiro ran gitleaks and TruffleHog over every public copy. Gitleaks flagged 564 of the 1,122 files with secrets. TruffleHog flagged 643. Neither flagged 215 of them. A clean scanner report is not a clean bill of health.&lt;/p&gt;

&lt;p&gt;The gap is passwords inside commands. Scanners look for key formats with recognizable prefixes. &lt;code&gt;PGPASSWORD=hunter2&lt;/code&gt;, a password after &lt;code&gt;sshpass -p&lt;/code&gt;, or &lt;code&gt;mysql -p&lt;/code&gt; looks like an ordinary word in an ordinary command line to a regex tuned for &lt;code&gt;AKIA..&lt;/code&gt; and &lt;code&gt;ghp_..&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 20-minute audit
&lt;/h2&gt;

&lt;p&gt;Do this today, before writing another allow rule:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Search your GitHub org for both &lt;code&gt;.claude/settings.local.json&lt;/code&gt; and &lt;code&gt;.claude/settings.json&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Check git history for those paths even where the file is gone today: &lt;code&gt;git log --all --full-history -- .claude/settings.local.json&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Rotate every credential those files have ever held, before any cleanup. Removing the file does not clear history or forks.&lt;/li&gt;
&lt;li&gt;Untrack it and protect it in the repo itself: &lt;code&gt;git rm --cached .claude/settings.local.json&lt;/code&gt;, then add the path to the repository's &lt;code&gt;.gitignore&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Open the local copy on your own machine and delete every rule that contains a password, token, key, or connection string, even if it was never committed.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Apiiro's advice on ordering matters: rotate first, clean up second. One company they notified confirmed its key had been live.&lt;/p&gt;

&lt;h2&gt;
  
  
  Write allow rules that cannot leak
&lt;/h2&gt;

&lt;p&gt;The fix is to stop approving literal commands that carry secrets. Two habits cover most of it.&lt;/p&gt;

&lt;p&gt;Pass secrets as environment variables from a secrets manager, so the saved rule records &lt;code&gt;$DB_URL&lt;/code&gt; and not the value:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;Bash&lt;span class="o"&gt;(&lt;/span&gt;psql &lt;span class="nv"&gt;$DB_URL&lt;/span&gt; -f migrate.sql&lt;span class="o"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And approve patterns instead of exact commands. A prefix rule like this approves the whole script family without ever recording a connection string:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"permissions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"allow"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"Bash(npm run:*)"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"Bash(./scripts/migrate:*)"&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The same release train that made this news cycle also gave teams a better lever: Claude Code 2.1.319 ships &lt;code&gt;permissions.denyInsteadOfPrompting&lt;/code&gt;, which denies a would-be prompt and continues instead of teaching you to click "don't ask again" by reflex. For unattended runs, a deny rule for anything matching &lt;code&gt;PGPASSWORD=*&lt;/code&gt; or &lt;code&gt;*AKIA*&lt;/code&gt; in the command is cheap insurance.&lt;/p&gt;

&lt;h2&gt;
  
  
  Treat agent folders like .env
&lt;/h2&gt;

&lt;p&gt;The wider lesson extends past one tool. Apiiro compared 16 coding agents and found Claude Code is the only one confirmed to save the full approved command to a project file by default, but &lt;code&gt;.cursor/&lt;/code&gt;, &lt;code&gt;.gemini/&lt;/code&gt;, &lt;code&gt;.specstory/&lt;/code&gt;, and agent memory files all accumulate context that can include credentials. Treat them like &lt;code&gt;.env&lt;/code&gt;: in pre-commit hooks, in CI secret scanning, in &lt;code&gt;.gitignore&lt;/code&gt; templates, and in Docker build contexts and package file lists, because Apiiro notes the file can leave your machine inside an npm package or an image without git ever being involved.&lt;/p&gt;

&lt;p&gt;Treat agent config folders as secret-bearing from day one, and audit the ones you already have. The 20-minute audit above needs nothing beyond git and an afternoon coffee.&lt;/p&gt;

&lt;p&gt;Sources: &lt;a href="https://thehackernews.com/2026/11/claude-codes-dont-ask-again-file.html" rel="noopener noreferrer"&gt;The Hacker News&lt;/a&gt;, &lt;a href="https://arstechnica.com/ai/2026/11/claude-code-settings-files-expose-thousands-of-secrets-on-github/" rel="noopener noreferrer"&gt;Ars Technica&lt;/a&gt;, Apiiro research write-up (November 5, 2026).&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>claude</category>
      <category>devtools</category>
    </item>
    <item>
      <title>MCP's file transfer draft keeps bytes out of your model's context: 5 mechanics and 3 open security questions</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Thu, 12 Nov 2026 13:06:58 +0000</pubDate>
      <link>https://dev.to/piekwerk/mcps-file-transfer-draft-keeps-bytes-out-of-your-models-context-5-mechanics-and-3-open-security-16dd</link>
      <guid>https://dev.to/piekwerk/mcps-file-transfer-draft-keeps-bytes-out-of-your-models-context-5-mechanics-and-3-open-security-16dd</guid>
      <description>&lt;p&gt;Yesterday the MCP maintainers published the first draft of an extension for moving files between clients and tools. If you build MCP servers, this is the piece you have been hand-rolling: base64 blobs in tool arguments, bespoke presigned-URL conventions, CSVs pasted into prompts. The extension, identified as &lt;code&gt;io.modelcontextprotocol/files&lt;/code&gt;, wants to standardize all of it. It works with protocol revision 2026-07-28 and later, and the maintainers expect it stable before the end of the year.&lt;/p&gt;

&lt;p&gt;I read the &lt;a href="https://blog.modelcontextprotocol.io/posts/exploring-file-uploads-and-downloads-in-mcp/" rel="noopener noreferrer"&gt;full announcement&lt;/a&gt; and the draft's mechanics. Here is what actually changes for a server author, and where the design still has open holes.&lt;/p&gt;

&lt;h2&gt;
  
  
  The core design decision: bytes never enter JSON-RPC
&lt;/h2&gt;

&lt;p&gt;Every scenario in the draft (save a PDF to cloud storage, pull a big CSV into a sandbox, upload a ZIP deck to a third-party service) shares one property. The model needs to know things about the file, but it never needs to read every byte.&lt;/p&gt;

&lt;p&gt;So the extension moves file contents out of band. Tool arguments carry metadata only: an id, a name, a mime type, a size, optionally a SHA-256 digest. The actual bytes travel over plain HTTPS PUT or POST, from the client directly to an upload target the server specifies. On the way back, downloads ride an HTTPS GET against a URL in the result's &lt;code&gt;_meta&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The consequence for your context window is the interesting part. The model makes the tool call and gets the result. Neither the file contents nor the upload URL ever enter its context. We &lt;a href="https://dev.to/piekwerk/i-measured-the-token-cost-of-9-mcp-servers-41k-tokens-before-the-first-prompt-mod"&gt;measured 41k tokens of MCP overhead before the first prompt&lt;/a&gt; on a typical server set. Any pattern that keeps bulk data out of the model's view is worth adopting early.&lt;/p&gt;

&lt;h2&gt;
  
  
  Mechanic 1: marking a file argument with x-mcp-file
&lt;/h2&gt;

&lt;p&gt;A server advertises a file argument by adding &lt;code&gt;x-mcp-file&lt;/code&gt; to the argument's input schema, the same pattern as &lt;code&gt;x-mcp-header&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="nl"&gt;"file"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"object"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"x-mcp-file"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"accept"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"application/pdf"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"maxSize"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;157286400&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"properties"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"minLength"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"maxLength"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;128&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nl"&gt;"mimeType"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nl"&gt;"size"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"integer"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"minimum"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nl"&gt;"data"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&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="nl"&gt;"required"&lt;/span&gt;&lt;span class="p"&gt;:&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="s2"&gt;"mimeType"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"size"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The client, not the model, fills this argument in. Small files can still go inline as base64 in &lt;code&gt;data&lt;/code&gt;, capped by a &lt;code&gt;maxInlineBytes&lt;/code&gt; value the server advertises in its &lt;code&gt;server/discover&lt;/code&gt; response. Anything bigger goes through the out-of-band flow below.&lt;/p&gt;

&lt;p&gt;There is a graceful degradation path: a client that does not support the extension ignores &lt;code&gt;x-mcp-file&lt;/code&gt; and treats the argument as an ordinary object. If the client never declared extension support in its &lt;code&gt;tools/list&lt;/code&gt; request, the server should omit the tool or offer an alternative that takes a URL.&lt;/p&gt;

&lt;h2&gt;
  
  
  Mechanic 2: metadata first, upload second
&lt;/h2&gt;

&lt;p&gt;Before anything is sent, the host gets the user's approval, or agent policy decides when no human is present. Then the client calls the tool with metadata only:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"method"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"tools/call"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"params"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"save_to_folder"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nl"&gt;"folderId"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"fld_8c1a"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="nl"&gt;"file"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"file-1"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"Q3 report.pdf"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                &lt;span class="nl"&gt;"mimeType"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"application/pdf"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"size"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;41204133&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This ordering is deliberate. The server can check permissions and storage quota before any bytes move. You do not upload 40 MB only to learn the destination folder is read-only. If checks pass, the server returns the extension's new &lt;code&gt;upload_required&lt;/code&gt; result type, containing one upload target per file: a URL, headers, an expiry, a &lt;code&gt;credentials&lt;/code&gt; mode, and a &lt;code&gt;requestState&lt;/code&gt; value.&lt;/p&gt;

&lt;h2&gt;
  
  
  Mechanic 3: requestState, built for the stateless core
&lt;/h2&gt;

&lt;p&gt;After the client PUTs the file and gets a 2xx, it calls the same tool again with the same arguments plus &lt;code&gt;requestState&lt;/code&gt; returned unchanged.&lt;/p&gt;

&lt;p&gt;That value represents the unfinished job. The server packages the details it needs to continue, protects the value against tampering, and hands it back. The client does not need to understand it. This fits the stateless direction MCP took in the July 28 revision, where persistent sessions went away. Any server instance that can verify the value and reach the uploaded file can finish the job. For tools where a second run would create a duplicate, the server marks the &lt;code&gt;requestState&lt;/code&gt; as used before running, and all instances share that record.&lt;/p&gt;

&lt;p&gt;This is the Multi Round-Trip Requests pattern, which shipped recently, applied to file transfer. If you write servers against the &lt;a href="https://dev.to/piekwerk/claude-code-21292-asks-your-mcp-servers-for-2026-07-28-i-probed-the-official-servers-all-four-b4b"&gt;2026-07-28 revision&lt;/a&gt;, the shape will look familiar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Mechanic 4: downloads ride in _meta
&lt;/h2&gt;

&lt;p&gt;Downloads are simpler because they do not need a retry. The tool completes normally, and the download target travels in the result's &lt;code&gt;_meta&lt;/code&gt; under the extension's id:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="nl"&gt;"result"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"resultType"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"complete"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"content"&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="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"text"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"text"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"Exported q3-orders.csv."&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="nl"&gt;"_meta"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"io.modelcontextprotocol/files"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nl"&gt;"downloads"&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="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"q3-orders.csv"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"mimeType"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"text/csv"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nl"&gt;"size"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;209715200&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nl"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"https://download.example.com/d/01JD3V9P4Q?sig=..."&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nl"&gt;"credentials"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"omit"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nl"&gt;"expiresAt"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"2026-11-04T18:30:00Z"&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The client only sees download targets if it declared &lt;code&gt;download&lt;/code&gt; support in the tool call. After fetching, it checks byte count against &lt;code&gt;size&lt;/code&gt;, and against &lt;code&gt;digest&lt;/code&gt; if one was supplied. A mismatch means discard the file.&lt;/p&gt;

&lt;p&gt;One line in the announcement deserves emphasis: a matching digest confirms the bytes match the hash, not that the file is safe. A malicious server can hand you a harmful file and its correct digest. Downloaded files stay untrusted input.&lt;/p&gt;

&lt;h2&gt;
  
  
  Mechanic 5: the credentials field
&lt;/h2&gt;

&lt;p&gt;A transfer target may be a third-party storage service, not the MCP server itself. So every target carries a &lt;code&gt;credentials&lt;/code&gt; mode. &lt;code&gt;omit&lt;/code&gt; means the client attaches no MCP token, cookies, or environment credentials; the target authorizes itself, typically via a presigned URL. &lt;code&gt;include&lt;/code&gt; means the client attaches its MCP credential, but only to a path under the client's own MCP address or the server's origin, which helps gateways and sandboxed clients.&lt;/p&gt;

&lt;p&gt;The draft also requires clients to refuse redirects on transfers and reject targets that supply an &lt;code&gt;Authorization&lt;/code&gt; header. Both close trivial exfiltration paths.&lt;/p&gt;

&lt;h2&gt;
  
  
  The three open questions
&lt;/h2&gt;

&lt;p&gt;The maintainers are explicit that this is a draft that may change shape, with no reference implementation yet. Three things are genuinely undecided:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Where download details belong.&lt;/strong&gt; &lt;code&gt;_meta&lt;/code&gt; is the current choice, and it is an open design question. If you have burned your fingers on result-shape drift, comment on the draft now rather than after it stabilizes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The allowlist question.&lt;/strong&gt; With &lt;code&gt;credentials: "omit"&lt;/code&gt;, a malicious server can still direct an upload to any public endpoint it controls. The host approves the transfer before it knows the target, so approval never covers the specific destination. The draft recommends hosts restrict omit targets to an allowlist of permitted origins. Whether that restriction should be mandatory is an open question.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Whether your stack needs it at all.&lt;/strong&gt; Servers that only ever take URLs to already-uploaded files do not need the extension, and the degradation path means those servers can keep their existing tool. The extension is optional by design.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  What I would do this week
&lt;/h2&gt;

&lt;p&gt;Nothing breaks today. The extension is experimental, optional, and unimplemented in the reference SDKs. But the direction matters: MCP is standardizing the last big chunk of bespoke server glue, and it is doing so in a way that keeps both the bytes and the URLs out of model context. If you run MCP servers for agents, &lt;a href="https://blog.modelcontextprotocol.io/posts/exploring-file-uploads-and-downloads-in-mcp/" rel="noopener noreferrer"&gt;read the draft&lt;/a&gt;, and if your tools shuffle files, your feedback window is now, before the shape hardens near year end. The maintainers take feedback in the extension repository's issues and the working group's Discord discussion.&lt;/p&gt;

&lt;p&gt;For broader context on how the 2026-07-28 stateless revision changed server authoring, see &lt;a href="https://dev.to/piekwerk/mcp-c-sdk-20-is-stable-http-is-stateless-by-default-and-10-changes-can-break-your-upgrade-g2o"&gt;MCP C# SDK 2.0 is stable: HTTP is stateless by default&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>31.7% of logged GitHub Agentic Workflows runs ended in failure: what 4.1 million archived runs show</title>
      <dc:creator>Piekwerk</dc:creator>
      <pubDate>Thu, 12 Nov 2026 07:34:18 +0000</pubDate>
      <link>https://dev.to/piekwerk/317-of-logged-github-agentic-workflows-runs-ended-in-failure-what-41-million-archived-runs-show-gjd</link>
      <guid>https://dev.to/piekwerk/317-of-logged-github-agentic-workflows-runs-ended-in-failure-what-41-million-archived-runs-show-gjd</guid>
      <description>&lt;p&gt;GitHub Agentic Workflows &lt;a href="https://github.blog/changelog/2026-10-28-github-agentic-workflows-generally-available/" rel="noopener noreferrer"&gt;went generally available on October 28&lt;/a&gt;, after a public preview that started in June. You write the automation as a Markdown file, the gh-aw compiler turns it into a standard GitHub Actions workflow, and a coding agent runs it on your existing runners with read-only defaults. A week after the general availability announcement, a research team published the first large-scale archive of what those workflows actually do in production. The headline number: 178,151 of 562,877 archived execution logs, or 31.7%, are linked to runs that ended with a failure conclusion.&lt;/p&gt;

&lt;p&gt;If GitHub infrastructure is now absorbing agent traffic at this scale, this dataset is the closest thing we have to a flight recorder. GitHub itself has been retooling for it, and I wrote about the storage side of that push when &lt;a href="https://dev.to/piekwerk/5000-agents-7200-pushes-a-second-inside-githubs-rubicon-and-the-git-guarantee-it-drops-2l9b"&gt;5,000 agents pushed 7,200 times a second inside GitHub's Rubicon&lt;/a&gt;. This paper covers the workflow layer sitting on top.&lt;/p&gt;

&lt;h2&gt;
  
  
  The setup: agents you write in Markdown
&lt;/h2&gt;

&lt;p&gt;A gh-aw workflow is a Markdown file in &lt;code&gt;.github/workflows/&lt;/code&gt; with YAML frontmatter. The frontmatter declares the trigger, permissions, allowed outputs, and any MCP servers. The prose below it is the task itself. Here is the example from the project's landing page:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;---
on: daily
safe-outputs:
  create-issue:
---
Summarise yesterday's issues. Flag
anything that needs a reply.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The file compiles into ordinary Actions YAML, runs behind the Agent Workflow Firewall in a sandboxed container, and can be powered by GitHub Copilot CLI, Claude Code, Codex, or Antigravity. Proposed changes go through a safe-outputs process, and a separate threat detection job scans them before anything is applied.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the researchers actually archived
&lt;/h2&gt;

&lt;p&gt;The paper, &lt;a href="https://arxiv.org/abs/2611.06866" rel="noopener noreferrer"&gt;GH-AWTrace (arXiv:2611.06866)&lt;/a&gt;, was submitted on November 4. The authors found candidate workflows through GitHub code search using the comment every compiled file carries, &lt;code&gt;This file was automatically generated by gh-aw&lt;/code&gt;, then verified each file actually had the generator header. That produced 25,014 verified workflows across 5,051 repositories.&lt;/p&gt;

&lt;p&gt;Then they collected runs. 4,112,526 run records spanning August 14, 2025 to September 21, 2026, which is as far back as GitHub's 400-day run retention reaches. Logs are the harder race: public workflow logs are deleted after at most 90 days. For the 90-day window they grabbed 1,633,215 log archives, 56.1 GB of ZIPs. Of those, 1,070,338 turned out empty. Another 821,672 runs had no downloadable archive at all. What survived is 562,877 nonempty archives, belonging to 561,367 runs.&lt;/p&gt;

&lt;p&gt;That survival filter matters for everything below. The dataset is what the retention window let them keep, not a clean sample.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 31.7% number, read carefully
&lt;/h2&gt;

&lt;p&gt;Of the 562,877 nonempty archives, 178,151 (31.7%) link to run records with a failure conclusion. The authors state the caveat themselves: this does not attribute every run failure to its agent. A run can fail because the runner died, because a provider hiccuped, or because the task was genuinely blocked. It is "a third of logged runs did not conclude clean", not "coding agents fail a third of the time".&lt;/p&gt;

&lt;p&gt;For comparison with self-reported agent success stories, this is still a sobering baseline. When I covered &lt;a href="https://dev.to/piekwerk/alibaba-measured-it-the-best-coding-agent-meets-70-of-requirements-and-finishes-26-of-tasks-52be"&gt;Alibaba's measurement that the best coding agent finished 26% of end-to-end tasks&lt;/a&gt;, the pushback was that lab tasks are artificially hard. These are real repositories running their own automations, and a third of logged runs still failed.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the failures look like in the logs
&lt;/h2&gt;

&lt;p&gt;Two examples from the paper stand out, because neither is a model failure.&lt;/p&gt;

&lt;p&gt;In one issue triage run, the agent called &lt;code&gt;issue_read&lt;/code&gt; on the GitHub MCP server and got back &lt;code&gt;McpError: filtered by integrity policy&lt;/code&gt;. The resource filter blocked the read, the agent could not triage what it could not see, and it reported the run as incomplete. The failure lived in the access policy, decided in frontmatter.&lt;/p&gt;

&lt;p&gt;In a failure scanner run, the agent hit &lt;code&gt;Authentication failed with provider&lt;/code&gt; on an internal endpoint, HTTP 403. The harness retried once, the second attempt failed the same way, and the job exited with code 1. Pure infrastructure.&lt;/p&gt;

&lt;p&gt;The logs also capture adaptation. One agent changed its publishing command after a tool denial and continued. One review run dispatched three background reviewers, got two responses back, and used agreement between those two to select findings. The authors note there was no evidence of memory shared across runs, only delegation within a run.&lt;/p&gt;

&lt;h2&gt;
  
  
  Schedule triggers dominate the count, one trigger dominates the volume
&lt;/h2&gt;

&lt;p&gt;Of the 6,040 workflows with logs, the median workflow produced 16 log archives in 90 days, with the middle half between 6 and 60. Schedule triggers are the common shape: 4,766 workflows (78.91%) run on a schedule, producing 252,691 logs (44.89%).&lt;/p&gt;

&lt;p&gt;The outlier is &lt;code&gt;pull_request_target&lt;/code&gt;. Fifty-nine workflows, 0.98% of the total, produced 73,594 logs, 13.07% of all log volume. That is roughly 1,247 executions per workflow versus about 53 for scheduled ones. &lt;code&gt;issue_comment&lt;/code&gt; shows a similar shape at smaller scale, 171 workflows generating 58,312 logs. If you wire an agent to react to pull requests or comments, you are not writing a cron job, you are writing a service that runs whenever anyone types. Budget and permission limits on those triggers are not optional hygiene, they are the whole ballgame.&lt;/p&gt;

&lt;h2&gt;
  
  
  Permissions decide the output shape, not just the safety
&lt;/h2&gt;

&lt;p&gt;My favorite case in the paper is a production workflow in Azure/azure-dev. Every week it reads feedback on merged pull requests and turns recurring reviewer requests into proposed updates to the repository's Copilot instructions. In August 2026 it examined 49 pull requests and proposed rules to reject ignored command-line flags and to redact credentials from URLs before printing them in logs.&lt;/p&gt;

&lt;p&gt;Repository settings prevented this workflow from opening a pull request. So it saved a branch and filed an issue with the patch instead, and a maintainer refined and merged the change through pull request #9731. The permission configuration determined the delivery mechanism, and the useful work still landed. That is the pattern I want from agent automation: the config decides what the agent can touch, and the agent degrades gracefully when it is told no. It rhymes with what I found when &lt;a href="https://dev.to/piekwerk/github-copilots-assisted-permissions-went-ga-an-llm-now-decides-which-commands-run-without-asking-3ej9"&gt;Copilot's assisted permissions went GA&lt;/a&gt;: the interesting design surface is increasingly who or what decides yes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Debug your own runs before the logs vanish
&lt;/h2&gt;

&lt;p&gt;gh-aw ships its own inspection tooling, and it is worth learning before you need it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh aw logs my-workflow -c 10 --start-date -1w --firewall
gh aw audit https://github.com/OWNER/REPO/actions/runs/12345678 --parse
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;gh aw logs&lt;/code&gt; groups failed, timed-out, and cancelled runs into failure investigation clusters using failed jobs, MCP failures, missing tools, and blocked domains. The docs are refreshingly blunt about the limits: clusters describe shared symptoms, not proven root causes, they can overlap, and you should not sum their counts into a failure rate. &lt;code&gt;gh aw audit&lt;/code&gt; breaks down a single run, including the behavior fingerprint, tool usage, MCP server status, and token and cost metrics.&lt;/p&gt;

&lt;p&gt;And archive anything you might want later. Public logs disappear after 90 days. The entire reason this dataset exists is that somebody raced that clock.&lt;/p&gt;

&lt;h2&gt;
  
  
  Read the whole thing honestly
&lt;/h2&gt;

&lt;p&gt;Independent review of the paper flags the weak spot: the 25,014 workflow denominator rests on a byte-exact header phrase plus a 384 KiB file-size cap in code search, with no cross-check against an independent enumeration. If the search index missed files, the headline counts are a sample of unknown recall, and the trigger distribution inherits that uncertainty.&lt;/p&gt;

&lt;p&gt;The authors are upfront that the logs are partial observations rather than complete trajectories, and that run conclusions do not equal task completion. That last gap is the one I keep thinking about. A workflow run can conclude successfully while the agent quietly did nothing useful, and no dashboard will tell you. The dataset is on &lt;a href="https://huggingface.co/datasets/jaykay9999/GHAWTrace" rel="noopener noreferrer"&gt;Hugging Face (jaykay9999/GHAWTrace)&lt;/a&gt; with a Python example that joins the tables and reproduces the 31.7% figure. If you run agentic workflows on real repositories, it is the best execution evidence available, warts and all.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>github</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
  </channel>
</rss>
