Daily Engineering Intelligence

Technology Newspaper

← Back to Home

Engineering Intelligence — Friday

October 9, 2026

🔥 What Changed

Security-release Friday. The Go team shipped Go 1.27.2 and Go 1.26.9 overnight with 15 security fixes across net/http, crypto/tls, cmd/go and friends — plan to bump toolchains and base images today. The second change is Temporal running a coding agent across Workers with claim-before-effect and lease fencing, so a crashed machine doesn’t blindly re-run a tool. One longer read: Uber’s SOSP paper on static analysis that labels outbound RPCs fail-close vs fail-open in Go.

Go otherwise stays quiet: no new go.dev post (newest is still archsimd). #82026 (compiler bug that can let the GC free a live object) still has CL 846325 in review with no compiler-team verdict — held. #81957 and #81759 are open. The #81864 cgroup GOMAXPROCS fix remains tip-only for Go 1.28.

Go 1.27.2 and Go 1.26.9: 15 security fixes — upgrade today

Released 2026-10-08 (announce 18:08 UTC / 23:38 IST). Both versions are on go.dev/dl as stable. The pre-announce listed ~10 private CVEs; the final announce covers 15 security fixes. Upgrade path: 1.27.x → 1.27.2, 1.26.x → 1.26.9. If you pin golang.org/x/net/http2 separately from the stdlib, bump to ≥ v0.60.0 (same-day companion for the HTTP/2 framing fix).

Highest-signal for backend HTTP / proxies / clients:

Area Impact CVE Issue
HTTP/2 server HPACK Concurrent SETTINGS_HEADER_TABLE_SIZE → encoder race → crash CVE-2026-97032 #81867
HTTP/2 Trailer Huge trailer field set → memory exhaustion past MaxHeader* CVE-2026-78659 #81857
HTTP/1 client / ReverseProxy CONNECT Rejected CONNECT leaves pooled conn desync’d → cross-user response poisoning; ReverseProxy now returns 405 for CONNECT (intentional) CVE-2026-56866 #81740
HTTP/1 server CONNECT 2xx CONNECT without hijack keeps serving HTTP on the tunnel → request smuggling risk CVE-2026-94439 #81744
HTTP/2 c/s → HTTP/1 Malformed framing-related headers forwarded → response smuggling (also fixed in x/net/http2) CVE-2026-78660 #81115
HTTP/2 window size Repeated SETTINGS_INITIAL_WINDOW_SIZE → excessive CPU (now O(1)) CVE-2026-78669 #81742
HTTP/2 flow control Double connection-level refund on reset streams → bypass MaxReceiveBufferPerConnection CVE-2026-78663 #81743
cmd/go Checksum bypass for bundled golang.org/fips140 via malicious project + GOMODPROXY CVE-2026-94444 #81833
cmd/go Checksum DB bypass for golang.org/toolchain via bogus go.sum + malicious proxy CVE-2026-94447 #81834

Also fixed (briefly): crypto/tls ECH outer-extension mem exhaustion (CVE-2026-97031); two html/template JS/context escape misses (CVE-2026-94448, CVE-2026-97030 — need attacker-influenced trusted templates); multipart MIME header parse past the memory limit when remaining budget <400B (CVE-2026-94440); Windows Root.Mkdir(All) following a junction out of root (CVE-2026-56857); FileServer/ServeContent huge multi-Range CPU (now capped at 200 ranges; CVE-2026-78667).

Impact / who / action: Any Go HTTP server, client, ReverseProxy, or service that trusts GOTOOLCHAIN / the module checksum DB. Action: rebuild images and toolchains on 1.27.2 or 1.26.9; bump pinned x/net ≥0.60.0; re-check any caller that relied on ReverseProxy accepting CONNECT (it now 405s). No exploitation is reported in the announce.

Why you care: Board Go 60. This is the patch you planned for after yesterday’s heads-up. The CONNECT/ReverseProxy and HTTP/2 framing items are the ones that bite shared Transports and proxies hardest; the cmd/go checksum bypasses matter if you use toolchain download or FIPS bundles behind a proxy you don’t fully trust.
golang-announce →  ·  Go 1.27.2 notes →  ·  Go 1.26.9 notes →  ·  x/net v0.60.0 →

Temporal: running the Pi coding agent so a dead Worker doesn’t re-fire the tool

Moe Abadi (Temporal, 2026-10-08) describes pi-temporal: a retrofit of the open-source Pi coding agent onto a Temporal Worker fleet. If a machine dies mid-turn, another Worker finishes the turn without automatically repeating the interrupted tool call. It builds on Earendil’s Pi Durable model (effect sandwich / claim before side effect), which Temporal calls right but whose built-in backends are single-process owners with no cross-process locking.

Design (from the primary):

  • One session = one Workflow. Each unit of work in a turn is an Activity: runModelCall (append answer), runToolCall (one tool), sealStep (record results in model order and decide whether to loop).
  • The Workflow holds no conversation state — “the transcript is the conversation state.” Each Activity rebuilds from the shared session file before acting.
  • Project files move as Git bundles written after each step; the next Worker applies the bundles it missed.
  • Claim-on-disk before the tool. Dispatch writes a claim beside the session file, then stores the result next to it. A retry that finds the result returns it. A retry that finds only the claim reports “outcome unknown… check current state before you try again” and lets the model inspect the world. Temporal’s attempt counter can’t answer this alone, because an attempt can fail before reaching the tool.
  • Model calls retry differently: re-read the transcript for a saved answer, else re-send the prompt (tokens, no side effect).
  • Zombie Workers: “Temporal can stop waiting for a Worker without proving that the Worker stopped.” Every append carries the Worker’s lease; a write guard rejects a stale attempt’s late append even if the bytes match. They tested by freezing a Worker, letting another take over, then resuming the first.
  • Single writer per step (sealStep); a started step stays pinned to one Worker because tools share a working directory. Per-turn and per-session token and time budgets, including a hard turn deadline.
  • Chaos demo: 3 Workers in Docker, active Worker killed every 15–40 s — “in the runs we’ve tested, the turn completes and the requested file is on disk.”
Why you care: Board DistSys 48; AI agents (Tier-2). This is the harness lesson from the other side of yesterday’s Cloudflare post: Cloudflare was about code owning evidence and citations; this is about what survives a crash. Transferable patterns for any Go worker pool over Temporal/Kafka with an outbox: intent record before the side effect; surface “unknown” instead of auto-retrying non-idempotent tools; fencing tokens against zombies; retry policy by side-effect class (pure model vs effectful tool). Caveats: vendor showcase and an experiment / small fork (repo brand-new); TypeScript not Go; no performance or cost numbers; the lease rejects late appends but does not stop external side effects already in flight; handover only for /background Worker tasks, not the local TUI.
Read on Temporal Blog →

📚 Worth Your Time

Uber RPCShield: static analysis that labels every outbound RPC fail-close or fail-open

Uber (with UBC/UW/UCR) presents RPCShield at SOSP ’26: a static-analysis suite in production ~2 years on Go (~6 months on Java). For every inbound RPC endpoint it decides whether each outbound RPC is fail-close (callee failure makes the caller fail) or fail-open, then flags cross-tier fail-close calls (a T0–T2 service failing because a lower-tier callee failed).

Key ideas:

  • Fail-close is a per-service, intra-service property — no cross-service analysis.
  • Decided counterfactually: “would the endpoint have succeeded had this one call succeeded?” That blames the specific dependency, not every error that passes through.
  • Four checks per function and call site: reachability, non-suppression, attributable (data or control dependence), causation.

Go internals:

  • Rapid Type Analysis over Go SSA; their optimized parallel RTA cut large-service runs from ~40 min to <15 s.
  • Async error flow modelled with synthetic edges from each task to its wait point — errgroup, raw go + channels, and Uber’s cff.Flow.
  • Nilness via extended SCCP, plus a second pass with the call’s error forced to nil (the counterfactual).
  • gRPC/Thrift stubs mapped to deployed services through IDL-generated types.

Numbers (from the paper):

  • Corpus: 6K+ services (4,618 Go / 1,577 Java); 3,944 analyzed.
  • Jan 2025–Aug 2026: 3,842 cross-tier violations; 1,359 remediated (421 code fixes, 938 re-tiered callees). FP rate ~5%; estimated miss rate vs runtime analysis 2.5%.
  • Median ticket lifetime 60 days; 72% of fixes took ≤5 days — “the fix is rarely the bottleneck; the queue is.”
  • Commit-time warnings: 449 reported, 101 (22%) fixed before merge.
  • 43 highest-severity incidents in 2020–23 attributed to fail-close dependencies; none attributed to cross-tier fail-close in 2025 — authors flag this as correlation, not causation.
  • Static layer under Uber’s differentiated failover, which reclaimed ~1M of 4M CPU cores.

Open source (Go): https://github.com/uber-research/rpcshield (Apache-2.0).

Why you care: Board Go 60 × DistSys 48 × Microservices/gRPC — the day’s strongest board fit after the security release. “Is this dependency fail-open?” sits behind every fallback, timeout and retry-budget decision; Uber also uses the labels to set retry policy. The async section matches Day-1 cancel ownership: errors from errgroup/goroutines only surface at the wait point. Complements UFA (09-27) and retry-storms (09-20) without overlapping either — this is how they find the fail-close edges. Caveats: correlational incident claim (stated); FP from internal review; research-grade OSS (Go only); can’t see latency or capacity inversions.
SOSP ’26 PDF →  ·  GitHub (uber-research/rpcshield) →