The Wire — 2026-06-17

Anthropic "pauses" token-based billing for its Claude Agent SDK

Anthropic paused a planned billing change for its Claude Agent SDK that would have shifted heavy users—including developers using Claude as a primary coding assistant—from generous subscription caps to prevailing API rates, effective June 15. The reversal follows similar token-based pricing backlash at GitHub Copilot and comes as Anthropic prepares for an IPO. The company acknowledged subscriptions weren't designed for third-party agent tool usage patterns, signaling the reprieve is temporary.

Why it matters

For platform engineers and AI agent builders relying on Claude for automated coding workflows, this directly impacts cost predictability and the viability of agent-heavy architectures built on subscription tiers.

AI/ML / martinfowler.com

Building Reliable Agentic AI Systems

Bayer and Thoughtworks built PRINCE, a cloud-hosted platform using Agentic RAG and Text-to-SQL to integrate decades of preclinical safety reports. The system employs specialized agents for intent clarification, reflection, and writing, with orchestration and observability designed for reliability. Key engineering decisions are framed as context engineering (shaping information flow between agents) and harness engineering (managing model behavior through recovery and human-in-the-loop controls).

AI/ML / infoq.com

GitHub Copilot Desktop App Targets Parallel Agentic Workflows

GitHub launched a desktop Copilot app in technical preview that serves as a control center for parallel agentic workflows, using git worktrees to isolate each agent session so teams can run multiple agents concurrently without branch conflicts. The app introduces Agent Merge for automated pull request handling through CI and review, bidirectional canvases for visualizing agent work, and local or cloud sandboxes with policy-based guardrails. It targets Copilot Pro, Pro+, Business, and Enterprise users, aiming to reduce context switching and opaque agent behavior by tying agents directly to existing GitHub workflows.

Languages / kobzol.github.io

How memory safety CVEs differ between Rust and C/C++

A deep dive into how memory safety CVEs are reported and perceived differently between Rust and C/C++, using the curl library as a concrete example. The author demonstrates that calling curl_getenv(NULL) in C causes a segfault (a memory safety bug), yet no one would report it as a CVE because the caller is responsible for passing valid arguments. In Rust, the type system and borrow checker would make such an API misuse either a compile-time error or require explicit unsafe, shifting the burden of proof from the caller to the library author. This asymmetry explains why raw CVE counts between Rust and C/C++ are misleading: Rust's safety guarantees push vulnerability classes into the unsafe boundary, where they are more visible and harder to accidentally trigger.

Cloud / notnotp.com

What job interviews taught me about Kubernetes

Job interviews across a dozen companies revealed that nearly every organization now uses Kubernetes, not for technical necessity but for organizational benefits: deployment uniformity, standardized knowledge transfer, and traceability via GitOps. CTOs at small startups with minimal scaling needs accept Kubernetes complexity for these non-technical wins, though the author argues most companies should start without it.

Open Source / gist.github.com

Stop Using JWTs

JWTs should not be used for user session management; they are designed for short-lived tokens (~5 minutes) and lack the security guarantees needed for persistent login. Stateless authentication is a fallacy—secure session handling requires server-side state, making traditional cookie sessions both safer and more flexible. Alternatives like PASETO exist for short-term tokens, but for sessions, use framework-native session middleware with a database-backed store.

Cloud / dev.to

AWS Blocks: Full-Stack Building Blocks That Run Locally Without an AWS Account

AWS Blocks is an open-source framework that lets developers build full-stack applications locally using self-contained building blocks that require zero AWS credentials, then deploy the same code to real AWS infrastructure with a single command. The framework uses an "Infrastructure from Code" approach where a single TypeScript file serves as both runtime logic and infrastructure definition, eliminating the need for separate CloudFormation, IAM policies, or sandbox account requests. Local development persists data to disk with hot reload and full type safety between frontend and backend, while production deployment provisions DynamoDB, API Gateway, and Lambda automatically via CDK under the hood.

DevTools / dev.to

The Playwright Playbook — Part 3: Multi-User, Multi-Tab & Browser Context Testing

Playwright's browser context architecture enables testing multi-user, multi-tab, and real-time collaboration scenarios in a single test by creating isolated environments with separate cookies, session storage, and auth state. This third installment of the Playwright Playbook series adds new page objects (DashboardPage), fixtures (multi-user.fixture.ts), and test specs for role-permissions and realtime-collaboration, building on prior foundations of POM, storageState, and network mocking. The approach solves a key limitation of most automation frameworks that test one user at a time, allowing simultaneous interactions like admin assigning tasks and users seeing real-time updates.

AI/ML / cncf.io

Why cloud native belongs at the heart of agentic AI: Lessons from building a multi-agent security platform on Kubernetes

This article likely discusses the rationale and practical lessons from building a multi-agent AI security platform on Kubernetes, presented at KubeCon Europe 2026. It probably argues that cloud-native principles (scalability, resilience, observability) are essential for production-grade agentic AI systems, addressing common questions about why Kubernetes is a suitable foundation for multi-agent orchestration.

AI/ML / dev.to

My AI agent got dumber mid-session. I measured the context window before blaming MCP.

An AI coding agent's performance degradation mid-session was traced not to MCP tool definitions, which consumed only a small slice of the context window, but to accumulated conversation history that silently filled roughly a fifth of the window. The author measured token allocation by category before disconnecting MCP servers, discovering that idle connected servers cost little when the client defers schema loading. The fix is pragmatic: start fresh sessions after completing a task rather than carrying full transcripts forward, or have the agent summarize key state to preserve continuity without bloating context.