The Software Architects' Newsletter
May 2026
View in browser

Welcome to the InfoQ Software Architects' Newsletter! We bring you essential news and experience on emerging patterns and technologies from industry peers each month.

This month, we focus on "AI Trends: The Next Evolution of Software Tooling, Techniques, and Teams". Technologies, patterns, and practices from this topic span the entire "diffusion of innovation" graph in last year's "InfoQ Software Architecture and Design Trends Report".

From AI-augmented development workflows and evolving system design patterns to shifts in team structure, governance, and developer experience, we examine how architects are adapting to a rapidly changing landscape. As AI moves from experimentation to everyday practice, understanding its impact on socio-technical systems, decision-making, and long-term system evolution is becoming a core architectural concern.

News

The Hidden Risks of Automation and AI

J. Paul Reed discusses the "ironies of automation", a forty-year-old concept now amplified by AI. He explains how advanced systems often make the human operator more crucial, not less, while simultaneously degrading the skills needed to intervene. Sharing real-world stories of "AI-fueled" incidents, he shares why over-reliance on AI can double recovery times and how to maintain resilience.

What Teams Are Learning Building Agent Systems from Scratch

In this QCon AI presentation, Paulo Arruda discusses Shopify's evolution in AI adoption, moving from simple chat tools to a sophisticated swarm of specialized agents. He explains the transition from massive "all-in-one" prompts to lean, narrow-focused agent microservices that slash task times from hours to minutes. He also shares a forward-looking hypothesis about using filesystem-based adapters to address context bloat.

In a related QCon SF presentation, Amit Navindgi discusses Zoox's systematic shift from fragmented documentation to an AI-driven ecosystem. He explains how they built "Cortex”, a secure platform that integrates RAG, multimodal LLMs, and contributor-friendly agent APIs. He shares practical strategies for driving adoption through AI champions and hackathons, emphasizing the move from deterministic workflows to autonomous agents.

OpenAI Introduces WebSocket-Based Execution Mode to Reduce Latency in Agentic Workflows

OpenAI has introduced a WebSocket-based execution mode for its responses API to improve the performance of agentic workflows used in coding agents and real-time AI systems. The change replaces the traditional HTTP request-response pattern with a persistent, bidirectional connection between client and server, targeting latency and coordination overhead in multi-step reasoning workflows. According to OpenAI, early production use shows up to a forty percent reduction in latency and improved throughput in high-concurrency scenarios.

Cloudflare Announces Agent Memory, a Managed Persistent Memory Service for AI Agents

Cloudflare has announced Agent Memory, a managed service in private beta as part of its Agents Week, that gives AI agents persistent memory across sessions, context compaction, and restarts. Rather than stuffing everything into the context window, the service extracts structured memories from conversations and retrieves only what's relevant on demand.

The service addresses what the industry calls “context rot”. Even as context windows grow beyond one million tokens, research shows that output quality degrades as the context fills up. Developers face a trade-off between keeping everything and risking a drop in quality, or pruning aggressively and risking the loss of information the agent needs later.

Anthropic Traces Six Weeks of Claude Code Quality Complaints to Three Overlapping Product Changes

Anthropic has published an engineering postmortem explaining six weeks of user complaints about Claude Code's quality. Users reported wildly different symptoms depending on when they used Claude Code and which features they relied on. The reason for these issues was there were three unrelated product-layer changes shipped between March and April 2026, with each affecting a different slice of traffic on its own schedule. The API and underlying model weights were not affected. All three issues have been resolved as of April 20 (v2.1.116) and Anthropic has reset usage limits for all subscribers.

Case Study

MCP in the Java World: Bringing Architectural Strategy to LLM Integrations

In a recent article, "MCP in the Java World: Bringing Architectural Strategy to LLM Integrations", Matteo Rossi examines how the Model Context Protocol (MCP) and the emerging Java MCP SDK introduce architectural discipline to enterprise large language model (LLM) integrations. Rather than focusing on prompt engineering or AI experimentation, Rossi frames MCP as a protocol-based approach that allows architects to apply familiar enterprise concepts such as service boundaries, contracts, governance, and control planes to AI-enabled systems.

The article contrasts traditional SDK-based integrations with MCP-based integrations. SDK approaches tightly coupled applications with specific models or vendors and are often effective for prototyping. MCP instead introduces a standardized protocol layer between models and enterprise systems, supporting discoverable capabilities, clearer boundaries, and looser coupling between AI agents and backend services. Rossi argues that this approach mirrors earlier shifts in distributed systems and service-oriented architecture, where standard protocols enabled interoperability and long-term maintainability.

A central theme is the role of MCP servers as architectural boundaries similar to anti-corruption layers or API gateways. Models do not directly invoke APIs or infrastructure; instead, MCP exposes curated tools and resources through explicit contracts. This solution creates governance and security boundaries while reducing the risk of exposing entire internal APIs to AI systems. Rossi also highlights MCP’s runtime capability discovery model, which reduces hardcoded integrations and allows systems to evolve with more flexibility over time.

The article further explores the design of the Java MCP SDK, including its support for synchronous and asynchronous interaction models, transport abstraction, and Spring Framework integration. Rossi notes that the SDK enables teams to incrementally introduce MCP into existing JVM-based systems while retaining established operational practices around observability, dependency injection, configuration management, and resilience.

Rossi concludes that MCP represents a shift from model-centric integration toward protocol-oriented AI architecture. For enterprise architects, the key takeaway is that LLM interactions should increasingly be treated as distributed system interactions, subject to the same architectural rigor, governance, and lifecycle management as any other enterprise integration pattern.

AI is in every decision you're making now. Check your thinking with senior peers in InfoQ’s online certification and cohorts.

Spend 4 hours a week for 5 weeks with senior peers from other companies, working through the decisions you're actually making. Every online cohort has AI in the syllabus. Each is facilitated by well-respected senior practitioners in their domain. Topics include sociotechnical architecture with Luca Mezzalira (Jun 10), AI Engineering with Hien Luu (Jul 25), the non-technical side of tech teams with Manuel Pais (Jun 19). See upcoming InfoQ Online Certifications Program cohorts.

This content is a short summary of a recent InfoQ article by Matteo Rossi, "MCP in the Java World: Bringing Architectural Strategy to LLM Integrations".

To get notifications when InfoQ publishes content on these topics, follow "AI, ML & Data Engineering", "architecture and design", and "Artificial Intelligence" on InfoQ.

Missed a newsletter? You can find all of the previous issues on InfoQ.

Sponsored

Rethinking AppSec: Why Compiler-Level Security Changes the Architecture Conversation (June 11th Webinar) Application security is often bolted on after the fact—wrapped around binaries or injected at runtime—creating fragility, performance overhead, and gaps that only surface in production. This InfoQ webinar reframes security as a build-time transformation embedded directly into the compilation process. Architects will compare wrapper-based protection, runtime instrumentation, and compiler-level approaches, and how each affects performance, debuggability, and resilience. The session also highlights where common models create bottlenecks or single points of failure in distributed systems. Join us to rethink where security belongs in modern software delivery and how to design protection that scales. Register for the Webinar “Rethinking AppSec: Why Compiler‑Level Security Changes the Architecture Conversation,” sponsored by Guardsquare

Upcoming Events