<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Reetesh Kumar on Medium]]></title>
        <description><![CDATA[Stories by Reetesh Kumar on Medium]]></description>
        <link>https://medium.com/@reetesh043?source=rss-859db09d6506------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*FpUP4VFl8I4KNbgBkGCeHQ.jpeg</url>
            <title>Stories by Reetesh Kumar on Medium</title>
            <link>https://medium.com/@reetesh043?source=rss-859db09d6506------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 04:33:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@reetesh043/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How the AI Agent Loop Works: Inside the Architecture That Makes AI Agents Autonomous]]></title>
            <link>https://medium.com/@reetesh043/how-the-ai-agent-loop-works-inside-the-architecture-that-makes-ai-agents-autonomous-1fc51f7d59d3?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/1fc51f7d59d3</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agent-loop]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 05:31:01 GMT</pubDate>
            <atom:updated>2026-10-12T05:31:01.570Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ExibBZfablHuatDvDA4oIg.png" /></figure><h3>Introduction: From Chatbots to Autonomous AI Agents</h3><p>For years, interacting with artificial intelligence followed a familiar pattern:</p><p><strong>Ask a question → Get an answer.</strong></p><p>You provide a prompt, the language model processes it, and you receive a response. This works well for tasks such as summarising documents, explaining code, writing emails, and answering questions. But what happens when the task requires multiple decisions?</p><p>Imagine asking an AI assistant:</p><blockquote><em>Analyse my application’s production logs, identify the cause of the latest API failures, check whether a recent deployment introduced the issue, and create a GitHub issue with your findings.</em></blockquote><p>A traditional LLM cannot reliably complete this task through text generation alone. It needs to interact with external systems, gather evidence, execute operations, interpret the results, and decide what to do next. This is where <strong>AI agents</strong> come into the picture.</p><p>An AI agent combines a language model with tools, contextual state, execution logic, and feedback mechanisms to perform multi-step tasks. At the centre of this architecture sits a surprisingly simple concept:</p><p><strong>The Agent Loop.</strong></p><p>The loop allows an agent to repeatedly evaluate its situation, select an action, observe the outcome, and continue until it reaches a stopping condition. Understanding this mechanism is essential for anyone building applications with agentic AI.</p><h3>What Exactly Is an Agent Loop?</h3><p>An agent loop is a repeating execution cycle in which an AI model decides what action to take based on the information currently available.</p><p>The basic pattern looks like this:</p><p><strong>Reason → Act → Observe → Update Context → Repeat</strong></p><p>Unlike a traditional application with a fully predetermined execution path, an agent can dynamically choose its next action.</p><p>For example, a conventional workflow might execute:</p><ol><li>Fetch logs.</li><li>Analyse logs.</li><li>Generate report.</li><li>Return result.</li></ol><p>The sequence is fixed.</p><p>An agent, however, might discover during log analysis that it needs deployment history. After retrieving that history, it might decide to inspect a particular error trace, query monitoring metrics, or request human approval before taking further action. The execution path changes depending on the evidence gathered.</p><p>This distinction matters.</p><p><strong>A workflow follows predefined instructions. An agent can select actions dynamically within the boundaries established by its application.</strong></p><p>The concept is closely associated with ReAct, which stands for Reasoning and Acting. ReAct introduced a way of combining reasoning steps and actions so that a language model could use observations from its environment to inform subsequent decisions. Modern agent frameworks implement related patterns through structured tool calls and runtime orchestration.</p><h3>Understanding Each Component of the Agent Loop</h3><p>Let’s examine the architecture step by step.</p><h4>Step 1: User Input and Goal Definition</h4><p>Every agent execution starts with a trigger.</p><p>This could be a user request, an API call, a scheduled task, or an event from another application.</p><p>For example:</p><blockquote><em>Investigate why payment authorisation failures increased in the last 30 minutes.</em></blockquote><p>Before taking action, the system needs to establish what the task requires.</p><p>It may need to identify:</p><ul><li>The intended outcome.</li><li>Available data sources.</li><li>Tools and permissions.</li><li>Constraints and business rules.</li><li>Conditions for successful completion.</li></ul><p>The agent’s instructions determine how it should approach the work.</p><p>An agent designed for production incident analysis might be instructed to gather supporting evidence, avoid unsupported root-cause claims, and never restart infrastructure without authorisation.</p><p>These rules become part of the agent’s operational context.</p><h4>Step 2: Context Construction</h4><p>Before calling the language model, the agent runtime prepares the information the model needs.</p><p>This context can contain system instructions, conversation history, the user’s current request, available tool definitions, relevant memory, and previous tool results.</p><p>Conceptually:</p><pre>Agent Context =<br>    System Instructions<br>    + User Request<br>    + Conversation History<br>    + Tool Definitions<br>    + Relevant Memory<br>    + Previous Observations</pre><p>The context is important because the model does not automatically know everything the application has done. For instance, if an agent previously queried a monitoring system, the resulting metrics must be made available to the model for its next decision. Without that feedback, the model could repeat work or make decisions using outdated information. As an agent runs for longer, context management becomes an engineering challenge. Applications may need to summarise older events, retrieve relevant history, or maintain a separate structured state.</p><h4>Step 3: Reasoning and Decision-Making</h4><p>Now the language model receives the prepared context. It evaluates the task and determines the next appropriate action. In our payment incident example, the agent might decide that it needs authorisation decline metrics before it can investigate further.</p><p>Its next action could be a structured request to a monitoring tool:</p><pre>Tool: get_authorization_metrics<br><br>Arguments:<br>    time_window: &quot;last_30_minutes&quot;<br>    group_by: &quot;response_code&quot;</pre><p>The important detail is that the LLM generally does not execute this function itself. Instead, it generates a tool-call request that the surrounding application interprets.</p><p><strong>The model selects an action. The runtime is responsible for executing it. </strong>This separation creates a clear boundary between language-model decisions and actual operations.</p><h4>Step 4: Tool Execution</h4><p>Once the model requests a tool, the agent runtime validates the request and invokes the corresponding integration.</p><p>Tools can provide access to external capabilities such as:</p><ul><li>Database queries and SQL execution.</li><li>Web searches and document retrieval.</li><li>REST APIs and internal services.</li><li>Python or shell execution.</li><li>GitHub repositories and issue tracking.</li><li>Monitoring and observability platforms.</li><li>Email, messaging, and calendar systems.</li></ul><p>In our example, the monitoring API might return:</p><pre>{<br>  &quot;authorization_success_rate&quot;: 82.4,<br>  &quot;baseline_success_rate&quot;: 97.8,<br>  &quot;top_decline_code&quot;: &quot;91&quot;,<br>  &quot;affected_acquirer&quot;: &quot;Acquirer_B&quot;,<br>  &quot;error_increase_started&quot;: &quot;14:05&quot;<br>}</pre><p>These are illustrative metrics.</p><p>The tool response provides fresh evidence that the model did not necessarily have when the task began. This is how agents move beyond their training data and interact with the current environment.</p><p>Tool execution also introduces risk. The runtime should validate parameters, authenticate requests, enforce permissions, and distinguish read-only operations from actions that change external systems.</p><h4>Step 5: Observation</h4><p>After executing a tool, the runtime captures its result and adds the relevant information to the agent’s context. The result may indicate that the action succeeded, returned no data, failed, timed out, or produced an unexpected response.</p><p>The agent can now use this observation to make another decision. Consider the previous example.</p><p>The response indicates that authorisation failures are concentrated around a particular acquirer, with response code 91. The agent might decide to investigate whether the acquirer is experiencing connectivity problems.</p><p>It could call another tool:</p><pre>Tool: get_acquirer_health<br>Arguments:<br>    acquirer: &quot;Acquirer_B&quot;</pre><p>The next result might reveal elevated connection timeouts and failed health checks. The investigation has progressed because the agent used its previous observation to choose the next action. This is the feedback mechanism that makes the loop useful.</p><h4>Step 6: Re-evaluation and Iteration</h4><p>The agent now has more information than it had during its first model call. It can reassess the goal and decide whether it needs additional evidence. A typical execution might look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W0nDBPbh3krLodzQQa4jrQ.png" /></figure><p>Each iteration uses information from previous steps. The agent is not necessarily following a script written in advance. It is selecting from available actions as new evidence becomes available. Importantly, this does not mean agents are infallible. They can misinterpret evidence, choose inappropriate tools, or become trapped in repetitive actions. This is why the surrounding runtime must enforce constraints.</p><h4>Step 7: Stopping and Final Output</h4><p>The agent loop cannot continue indefinitely.</p><p>A well-designed system needs explicit termination conditions.</p><p>An execution might stop when:</p><ol><li>The model returns a final answer without requesting more tools.</li><li>The task’s completion criteria have been satisfied.</li><li>The maximum number of iterations is reached.</li><li>The execution exceeds a time or cost budget.</li><li>A tool error cannot be recovered from safely.</li><li>Human approval or additional information is required.</li></ol><p>For our incident example, the agent might produce:</p><p><strong>Investigation Summary: </strong>Authorisation success rates decreased from 97.8% to 82.4%, with the decline concentrated on Acquirer B. Monitoring data indicates increased connection timeouts beginning at 14:05. No related deployment was identified during the investigation.</p><p><strong>Recommended Action: </strong>Escalate to the acquiring connectivity team and evaluate routing eligible traffic through the backup acquirer, subject to the organization’s failover controls and approval requirements. The agent’s result contains findings and recommendations grounded in the collected observations.</p><p>It has completed the investigation without automatically performing a potentially high-impact infrastructure change.</p><h3>What Happens Behind the Scenes? A Technical Perspective</h3><p>The fundamental control flow of an agent can be expressed using a relatively small amount of pseudocode.</p><pre>def run_agent(user_request):<br>    context = initialize_context(user_request)<br><br>for iteration in range(MAX_ITERATIONS):<br>        response = call_llm(<br>            messages=context,<br>            tools=available_tools<br>        )<br>        if response.is_final:<br>            return response.answer<br>        if response.requires_tool:<br>            tool_call = response.tool_call<br>            validate_tool_call(tool_call)<br>            result = execute_tool(<br>                tool_call.name,<br>                tool_call.arguments<br>            )<br>            context.append(response)<br>            context.append(result)<br>    raise RuntimeError(<br>        &quot;Agent exceeded maximum iterations&quot;<br>    )</pre><p>This is conceptual pseudocode rather than an implementation tied to a particular SDK. Despite its simplicity, it captures the central mechanics of an agentic system. The application repeatedly calls the model, examines the response, executes requested tools, and sends observations back to the model.</p><p>A real implementation must additionally handle structured message protocols, multiple tool calls, retries, authorisation, exception handling, cancellation, and persistence.</p><h4>Who Actually Controls the Loop?</h4><p>This is an important architectural distinction. The LLM does not generally own the execution loop. The <strong>agent runtime</strong>, sometimes called the agent harness, controls it.</p><p>The runtime determines which tools are exposed, whether a proposed tool call is permitted, how results are recorded, when the model is called again, and when the execution must stop. The LLM influences the next action within these boundaries. In other words:</p><p><strong>The model provides decisions. The runtime enforces execution.</strong></p><h3>Implementing an Agent Loop Using the OpenAI Agents SDK</h3><p>Modern frameworks remove much of the boilerplate associated with writing your own execution loop. For example, the OpenAI Agents SDK provides an agent abstraction, a tool interface, and a runner that manages the agent lifecycle.</p><p>Below is a simplified Python example.</p><pre>import asyncio<br><br>from agents import Agent, Runner, function_tool<br><br>@function_tool<br>def get_service_health(service: str) -&gt; str:<br>    &quot;&quot;&quot;Return the current health of a service.&quot;&quot;&quot;<br>    # Example data. Replace with a real monitoring API.<br>    return (<br>        f&quot;{service}: degraded. &quot;<br>        &quot;Elevated latency and timeout errors detected.&quot;<br>    )<br><br>@function_tool<br>def get_recent_deployments(service: str) -&gt; str:<br>    &quot;&quot;&quot;Return recent deployment information.&quot;&quot;&quot;<br>    # Example data. Replace with deployment API.<br>    return (<br>        f&quot;{service}: no deployments &quot;<br>        &quot;during the last 60 minutes.&quot;<br>    )<br><br>agent = Agent(<br>    name=&quot;Incident Investigator&quot;,<br>    instructions=(<br>        &quot;Investigate service incidents using available &quot;<br>        &quot;tools. Gather supporting evidence before &quot;<br>        &quot;drawing conclusions. Distinguish facts from &quot;<br>        &quot;hypotheses. Do not claim an incident is &quot;<br>        &quot;resolved without verification.&quot;<br>    ),<br>    tools=[<br>        get_service_health,<br>        get_recent_deployments<br>    ]<br>)<br><br>async def main():<br>    result = await Runner.run(<br>        agent,<br>        &quot;Investigate the payment API degradation.&quot;,<br>        max_turns=8<br>    )<br>    print(result.final_output)<br><br>if __name__ == &quot;__main__&quot;:<br>    asyncio.run(main())</pre><p>The example uses simulated monitoring data, but the tools can be connected to actual operational systems.</p><h4>How the SDK Handles Execution</h4><p>When the runner starts, it sends the task and agent configuration to the model. If the model requests get_service_health, the SDK executes that function and incorporates the result into the next model interaction.</p><p>The model may then request get_recent_deployments. After reviewing both observations, it can generate a final response. The SDK handles the repeated model and tool interactions without requiring the developer to manually implement the entire loop.</p><p>That allows developers to focus on tool design, permissions, state management, evaluation, and business-specific logic.</p><h3>Agent Loop vs Traditional Workflow vs RAG</h3><p>These concepts are frequently discussed together, but they solve different problems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ii4UOFUisVVxx6DlSJNRBg.png" /></figure><h3>Memory and State: How Agents Maintain Continuity</h3><p>An agent working through a multi-step task needs to track what has already happened. Without state, every iteration would effectively start from scratch. Agent systems commonly work with several forms of contextual information.</p><h4>Short-Term Memory</h4><p>Short-term memory represents information relevant to the current interaction or execution. It might include conversation messages, tool responses, intermediate findings, and outstanding tasks.</p><p>For example:</p><pre>Current Task:<br>Investigate payment failures<br><br>Observations:<br>- Authorisation success rate decreased<br>- Acquirer B is experiencing timeouts<br>- No recent deployment found<br><br>Pending:<br>- Verify backup route status</pre><p>This information helps the agent determine what to do next.</p><h4>Long-Term Memory</h4><p>Long-term memory allows information to be retained across separate executions. Examples include user preferences, organisational policies, recurring patterns, and previously validated operational knowledge.</p><p>It is not necessarily stored inside the language model. Applications frequently maintain it externally in databases, document stores, or other persistent systems. When needed, relevant information can be retrieved and included in the model’s context.</p><h4>Working State</h4><p>Working state is often more structured than conversational memory. It can contain fields such as:</p><pre>{<br>  &quot;incident_id&quot;: &quot;INC-1042&quot;,<br>  &quot;status&quot;: &quot;investigating&quot;,<br>  &quot;tools_called&quot;: 3,<br>  &quot;evidence_count&quot;: 5,<br>  &quot;approval_required&quot;: true<br>}</pre><p>This structured information can be used by application code to enforce workflow rules, checkpoints, and stopping conditions. The distinction is useful: the model’s context supports decision-making, while structured state supports reliable execution.</p><h3>Guardrails: Why Agents Need Boundaries</h3><p>An AI agent capable of calling tools can do considerably more than produce text. That makes security and control essential.</p><p>Imagine an incident-response agent with permission to restart production services. If it incorrectly interprets an error as a service failure, an unauthorised restart could make the situation worse. A production system should not rely solely on natural-language instructions such as:</p><p><em>“Be careful when restarting services.”</em></p><p>It should enforce concrete restrictions through application code and infrastructure controls.</p><h4>Tool-Level Permissions</h4><p>Only expose the tools an agent genuinely needs. A diagnostic agent may need permission to read logs and metrics, but not to delete resources or change configurations.</p><h4>Human Approval</h4><p>High-impact operations should require appropriate authorisation.</p><p>For example:</p><pre>Agent Recommendation<br>        ↓<br>Restart Production Service?<br>        ↓<br>   Approval Required<br>     ↙       ↘<br>   Yes        No<br>    ↓          ↓<br>  Execute    Cancel<br>    ↓<br>Verify Result</pre><p>The decision to require approval should be enforced by the runtime, not merely suggested by the model.</p><h4>Iteration and Cost Limits</h4><p>Agent loops consume resources on every model call and tool invocation. Without limits, an agent could repeatedly execute similar actions while making little progress. Useful controls include maximum turns, timeouts, token budgets, tool-call limits, and spending thresholds.</p><h4>Protection Against Untrusted Content</h4><p>Agents frequently process information from websites, documents, logs, and APIs. These sources may contain misleading instructions or malicious prompt injection attempts. External content should be treated as data rather than authority to override the agent’s instructions or permissions.</p><p>This becomes especially important when tools can modify production systems or access sensitive information.</p><h3>Common Agent Loop Failure Modes</h3><p>The loop architecture is powerful, but it introduces several engineering challenges.</p><h4>Infinite or Repetitive Loops</h4><p>An agent might repeatedly call the same tool with nearly identical arguments. A useful defence is detecting repeated actions that produce no meaningful progress and terminating the execution or changing strategy.</p><h4>Hallucinated Tool Arguments</h4><p>The model may provide incorrect parameters, unsupported identifiers, or invalid values. Tool schemas and runtime validation should reject malformed requests before execution.</p><h4>Incorrect Interpretation of Results</h4><p>A tool can return accurate data while the model draws an incorrect conclusion. For this reason, critical decisions should be supported by explicit validation, independently checked evidence, or human review.</p><h4>Context Window Growth</h4><p>Every iteration can introduce more messages and observations. Over time, large contexts increase cost and may reduce focus. Strategies include context summarisation, selective retrieval, and keeping operational state outside the prompt.</p><h4>Premature Completion</h4><p>An agent might produce a final answer before verifying whether the task was actually completed. For example, generating a code patch is not the same as confirming the patch passes tests. The runtime can require external verification before accepting completion.</p><h4>Excessive Autonomy</h4><p>Allowing the model to execute every action without restrictions creates unnecessary operational risk. A better design provides autonomy where dynamic reasoning creates value and uses deterministic controls where safety and predictability matter.</p><h3>Observability: Understanding What an Agent Actually Did</h3><p>Traditional applications are usually monitored through logs, metrics, and traces. Agentic applications need similar visibility, but the execution path is often less predictable.</p><p>Useful agent telemetry includes:</p><ul><li>Individual model calls and their latency.</li><li>Tool names, arguments, and execution outcomes.</li><li>Number of iterations per task.</li><li>Token usage and estimated cost.</li><li>Errors, retries, and timeouts.</li><li>Approval decisions.</li><li>Final task success or failure.</li></ul><p>For example, an execution trace might look like this:</p><pre>Run ID: agent-run-481<br><br>Step 1:<br>  Model requested get_service_health<br>  Status: Success<br>Step 2:<br>  Model requested get_recent_deployments<br>  Status: Success<br>Step 3:<br>  Model evaluated returned evidence<br>Step 4:<br>  Final response generated<br>Total model calls: 3<br>Total tool calls: 2<br>Run status: Completed</pre><p>This visibility helps developers answer important questions.</p><p>Why did the agent select a particular tool? Which observation led to its conclusion? Why did the execution take six iterations rather than three? Did the agent actually satisfy the user’s request? Tracing allows teams to investigate these questions, while evaluation frameworks can test whether agents perform reliably across different scenarios.</p><p>For production systems, measuring the quality of the outcome is more useful than simply counting completed model calls.</p><h3>Single-Agent and Multi-Agent Architectures</h3><p>The agent loop can also be extended into multi-agent systems. Instead of one agent handling an entire task, a coordinating agent can delegate specialised work.</p><p>For example, an incident investigation might involve:</p><p><strong>Monitoring Agent:</strong> Retrieves application health, latency, error rates, and operational metrics.</p><p><strong>Deployment Agent:</strong> Examines recent releases, configuration changes, and deployment history.</p><p><strong>Incident Analysis Agent:</strong> Correlates evidence and formulates possible causes.</p><p><strong>Coordinator Agent:</strong> Assigns work, combines findings, and prepares the final result.</p><p>Each specialist can operate within its own bounded execution loop. The coordinator manages dependencies and determines when sufficient information has been gathered. <strong><em>Multi-agent architectures </em></strong>can help when responsibilities are clearly separable, but they also introduce additional latency, cost, coordination complexity, and failure points. A <strong><em>single agent</em></strong> with well-designed tools is often the better starting point.</p><p>The goal is not to maximise the number of agents. It is to solve the task reliably with the least unnecessary complexity.</p><h3>Best Practices for Building Production-Ready Agent Loops</h3><p>An effective agent system requires more than a capable language model. A few engineering principles make a substantial difference.</p><p><strong>Start with clear completion criteria.</strong> Define what success looks like before the agent begins. Where possible, completion should be externally verifiable.</p><p><strong>Keep tools narrow and predictable.</strong> Small, well-defined operations are easier to validate and troubleshoot than tools with broad, ambiguous responsibilities.</p><p><strong>Separate reasoning from execution.</strong> Let the model select appropriate actions while application code enforces permissions, validation, and operational rules.</p><p><strong>Make read-only operations the default.</strong> Require additional authorization for irreversible, expensive, or high-impact actions.</p><p><strong>Persist important state.</strong> Do not rely entirely on a growing conversation history to track critical execution information.</p><p><strong>Design for failure.</strong> Tool timeouts, empty results, conflicting evidence, and unavailable services should have defined handling strategies.</p><p><strong>Limit iteration and resource usage.</strong> Ensure the agent can stop when it is making insufficient progress.</p><p><strong>Verify results independently.</strong> Use tests, database checks, API responses, or external evaluators instead of relying only on the model’s statement that it has completed the task.</p><p><strong>Observe every execution.</strong> Collect traces and metrics so failures can be reproduced, investigated, and improved.</p><p>Perhaps the most important principle is to use an agent only when the problem genuinely benefits from dynamic decision-making. Not every automation requires autonomy.</p><h3>Conclusion</h3><p>At its core, the agent loop is a simple feedback mechanism.</p><p>The model receives context, determines the next action, interacts with tools through a runtime, observes the results, and repeats as necessary. This feedback cycle changes how language models can be used in software applications. Instead of being limited to a single generated response, they can participate in processes that require multiple stages of evidence gathering, decision-making, and execution.</p><p>However, the loop alone does not make a system reliable. Reliability comes from combining model capabilities with well-designed tools, bounded execution, structured state, verification, observability, and human oversight where appropriate.</p><p><strong><em>The real power of agentic AI is not that a model can act independently. It is that the system can use feedback to decide what to do next, while remaining within controlled and verifiable boundaries.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1fc51f7d59d3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s New in Java 27: Memory Savings, JVM Upgrades, and More]]></title>
            <link>https://medium.com/@reetesh043/whats-new-in-java-27-memory-savings-jvm-upgrades-and-more-c8b5d4fd8ed6?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8b5d4fd8ed6</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[jdk27]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Sat, 10 Oct 2026 21:40:58 GMT</pubDate>
            <atom:updated>2026-10-10T21:40:58.377Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6huCSR4NQ-mMKhU2tZqXHg.png" /></figure><h3>Introduction</h3><p>For a language that has been around for more than three decades, Java has a remarkable ability to stay relevant.</p><p>Every few years, someone predicts that Java is becoming outdated. Yet it continues to power financial systems, enterprise applications, cloud infrastructure, Android ecosystems, and mission-critical services across industries. And with <strong>JDK 27, released on September 15, 2026</strong>, Java takes another meaningful step forward.</p><p>This release is not about introducing flashy syntax or reinventing how developers write applications. Instead, it focuses on challenges that matter in modern software engineering:</p><ul><li>Making Java applications more memory-efficient.</li><li>Improving concurrent programming.</li><li>Strengthening security against future quantum computing threats.</li><li>Reducing unnecessary initialisation costs.</li><li>Improving JVM diagnostics and observability.</li><li>Supporting high-performance computing and AI workloads.</li></ul><p>JDK 27 introduces <strong>nine JDK Enhancement Proposals (JEPs)</strong>, including four preview features and one incubating API. Some improvements are immediately useful in production. Others provide a glimpse into Java’s future. Let’s explore what’s new, why it matters, and whether you should consider moving to JDK 27.</p><h3>1. Compact Object Headers: Smaller Objects, Better Memory Efficiency</h3><p><strong>JEP 534: Compact Object Headers by Default</strong></p><p>One of the most practically significant improvements in Java 27 is the default adoption of compact object headers. Every Java object requires metadata that the JVM uses internally. This metadata can include information associated with object identity, synchronisation, and garbage collection.</p><p>Traditionally, object headers contribute a non-trivial amount of memory overhead, especially in applications creating millions of small objects.</p><p>Java 27 makes compact object headers the default on supported 64-bit HotSpot configurations.</p><h4>What changes?</h4><p>The object header can shrink from <strong>96 bits to 64 bits</strong>. That is a reduction from 12 bytes to 8 bytes. Consider a service holding millions of small domain objects. Even a modest reduction in per-object overhead can make a noticeable difference to total memory consumption.</p><p>For example, if an application contains 10 million objects and each one saves four bytes of header space, the theoretical direct saving is:</p><p>10,000,000 × 4 bytes = 40 MB.</p><p>This simplified calculation excludes object alignment, changes to object layout, and other JVM considerations. Actual memory savings will vary.</p><h4>Why does this matter?</h4><p>In large Java deployments, memory efficiency affects more than heap consumption. It can influence:</p><ul><li>Garbage collection pressure.</li><li>CPU cache utilisation.</li><li>Application deployment density.</li><li>Container memory requirements.</li><li>Infrastructure operating costs.</li></ul><p>A small memory optimisation at the JVM level can be valuable when an organisation runs hundreds of microservices.</p><p><strong>My takeaway:</strong> This is exactly the kind of improvement enterprise Java needs. Applications may benefit without developers having to rewrite business logic.</p><h3>2. G1 Becomes the Default Garbage Collector Everywhere</h3><p>Garbage collection has always been central to Java’s memory management story. Java automatically reclaims unused memory, allowing developers to focus on application logic rather than manually freeing objects.</p><p>However, garbage collection choices can influence latency, throughput, CPU usage, and memory consumption. Previously, HotSpot could select different default garbage collectors depending on the runtime environment. For instance, resource-constrained environments could select Serial GC instead of G1.</p><p>With Java 27, <strong>G1 becomes the default garbage collector across all environments</strong> when no collector is explicitly specified.</p><h4>Why G1?</h4><p>G1, short for Garbage-First, is designed to balance throughput and pause-time goals. Instead of treating the entire heap as a single continuous collection target, G1 divides the heap into regions.</p><p>It prioritises regions that are likely to provide the most useful memory reclamation. This helps the JVM manage garbage collection more predictably.</p><h4>What does this mean for microservices?</h4><p>Imagine a Spring Boot application running inside a container with limited memory and CPU.</p><p>The JVM’s choice of garbage collector can affect:</p><ul><li>Startup performance.</li><li>Memory footprint.</li><li>Response-time consistency.</li><li>CPU consumption.</li><li>Garbage collection pauses.</li></ul><p>Java 27 creates more consistent default behaviour across deployment environments. That does not mean G1 is automatically the fastest collector for every workload. Applications with extremely small heaps, strict latency requirements, or specialised throughput needs may still benefit from explicitly choosing another collector.</p><h4>Example: Selecting G1 explicitly</h4><pre>java -XX:+UseG1GC -jar application.jar</pre><p>With Java 27, this flag is generally unnecessary if you want the default collector, but explicitly selecting it can still help maintain consistent JVM configuration across environments.</p><h4>Verify the active collector</h4><pre>java -Xlog:gc -jar application.jar</pre><p>Review the startup logs to confirm the selected garbage collector.</p><p><strong>Developer insight:</strong> JVM defaults are improving, but performance engineering still requires measurement. Always benchmark applications under realistic traffic, heap sizes, and container limits.</p><h3>3. Structured Concurrency: Making Concurrent Java Code Easier to Manage</h3><p>Concurrency is one of the most powerful and challenging areas of Java development. Modern backend applications frequently need to execute multiple independent tasks simultaneously.</p><p>Consider an e-commerce application that needs to retrieve:</p><ol><li>Customer details.</li><li>Product availability.</li><li>Pricing information.</li></ol><p>These operations might involve different downstream services. Executing them sequentially increases the total response time. Running them concurrently improves responsiveness, but introduces questions: What happens if one task fails? What if the client disconnects? Should the remaining tasks continue running? Who is responsible for cancellation?</p><p>Traditional approaches using thread pools and futures can make these situations difficult to manage. Structured concurrency aims to solve this problem.</p><h4>The core idea</h4><p>Related concurrent tasks should belong to a well-defined scope. Their lifetime should be controlled by the code that creates them. This makes it easier to reason about cancellation, failures, and task completion.</p><p>Consider this simplified sequential example:</p><pre>public OrderSummary getOrderSummary(String orderId) {<br>    Customer customer = fetchCustomer(orderId);<br>    Pricing pricing = fetchPricing(orderId);<br>    return new OrderSummary(customer, pricing);<br>}</pre><p>The two requests execute one after another. If each takes 200 milliseconds, their combined waiting time could approach 400 milliseconds. Concurrent execution can reduce the total waiting time when the operations are independent. Structured concurrency provides an approach for managing such operations as one logical unit.</p><h4>Why is this important?</h4><p>Structured concurrency can improve:</p><ul><li>Error propagation.</li><li>Cancellation handling.</li><li>Thread lifecycle management.</li><li>Code readability.</li><li>Observability.</li><li>Reliability of distributed applications.</li></ul><p>It also works naturally with the broader direction of Java’s virtual-thread capabilities.</p><h4>Real-world example</h4><p>Think about a payment authorisation service. The service might need to check account information, fraud signals, and transaction rules. Some checks can run independently. If a mandatory check fails, the application may need to cancel related tasks and return a response promptly. Structured concurrency helps developers represent that relationship more explicitly.</p><p><strong>Important:</strong> Structured concurrency remains a preview API in Java 27. Its API and behaviour may evolve before finalisation. For now, it is worth evaluating, especially when building highly concurrent services.</p><h3>4. Post-Quantum Cryptography: Preparing Java for Future Security Threats</h3><p>Perhaps the most forward-looking enhancement in JDK 27 is its support for post-quantum hybrid key exchange in TLS 1.3. Modern applications rely heavily on encryption. Whenever a Java application communicates securely with an API, payment provider, database endpoint, or external service, cryptographic protocols may be involved.</p><p>Much of today’s public-key cryptography relies on mathematical problems that are extremely difficult for classical computers to solve. However, sufficiently capable quantum computers could eventually threaten some of these algorithms. Java is preparing for that possibility.</p><h4>What is hybrid key exchange?</h4><p>Hybrid key exchange combines two cryptographic approaches:</p><ul><li>A traditional key-exchange algorithm.</li><li>A quantum-resistant key-encapsulation mechanism.</li></ul><p>The objective is to maintain security even if one of the components becomes vulnerable.</p><h4>Why not immediately replace traditional cryptography?</h4><p>Because cryptographic transitions are complicated. Organisations operate across different platforms, hardware, networks, and security requirements.</p><p>Hybrid approaches provide a practical migration path while new cryptographic standards and implementations mature.</p><h4>What changes for Java developers?</h4><p>Applications using Java’s standard TLS infrastructure, including javax.net.ssl, can benefit from the new hybrid key-exchange capabilities without requiring changes to ordinary application code. However, the actual negotiation depends on compatible endpoints, TLS configuration, provider support, and enabled algorithms. Developers should not assume every TLS connection automatically becomes quantum-resistant simply because the application uses JDK 27.</p><h4>Why enterprises should pay attention</h4><p>This is particularly relevant for:</p><ul><li>Banking and financial services.</li><li>Healthcare systems.</li><li>Government applications.</li><li>Identity management platforms.</li><li>Long-lived encrypted data.</li><li>High-security communication systems.</li></ul><p>Data intercepted today may remain sensitive for many years. That creates a risk commonly described as <em>harvest now, decrypt later</em>, where attackers collect encrypted traffic in the hope of decrypting it in the future. Java 27 helps provide a stronger technical foundation for organisations preparing their cryptographic infrastructure.</p><h3>5. Primitive Types in Pattern Matching: More Expressive Java</h3><p>Java has made major improvements to pattern matching over recent releases. Features involving instanceof, records, and switch have helped reduce boilerplate code. However, Java’s primitive types have historically introduced restrictions that make some pattern-matching expressions inconsistent. JEP 532 continues the effort to make primitive types work more naturally with modern Java language constructs.</p><h4>A simple example</h4><p>Consider this traditional switch statement:</p><pre>static String classify(int value) {<br>   if (value &lt; 0) {<br>        return &quot;Negative&quot;;<br>    }<br>    return switch (value) {<br>        case 0 -&gt; &quot;Zero&quot;;<br>        case 1 -&gt; &quot;One&quot;;<br>        default -&gt; &quot;Positive&quot;;<br>    };<br>}</pre><p>This works, but it separates the numeric condition from the switch expression. With primitive patterns, a similar classification can be expressed more directly:</p><pre>static String classify(int value) {<br><br>   return switch (value) {<br>        case int n when n &lt; 0 -&gt; &quot;Negative&quot;;<br>        case 0 -&gt; &quot;Zero&quot;;<br>        case 1 -&gt; &quot;One&quot;;<br>        default -&gt; &quot;Positive&quot;;<br>    };<br>}</pre><p>The second example uses preview language functionality and requires preview features to be enabled.</p><h4>Why does this matter?</h4><p>The benefit is not simply fewer lines of code. It is greater consistency across Java’s type system. Developers can express certain conditions and type relationships in ways that align more naturally with modern pattern matching.</p><p>This can be useful in:</p><ul><li>Data processing.</li><li>Numeric classification.</li><li>Parsing.</li><li>Validation.</li><li>Rule-based processing.</li></ul><h4>Enable preview features</h4><p>For source files using Java 27 preview language features:</p><pre>javac --enable-preview --release 27 Example.java</pre><p>Run the application with:</p><pre>java --enable-preview Example</pre><p>Preview features are designed for evaluation and feedback. They should not be treated as permanently finalised language contracts.</p><h3>6. Lazy Constants: Initialise Resources Only When Needed</h3><p>Lazy initialisation is a common software engineering technique. The idea is straightforward: Why initialise something expensive if the application may never use it?</p><p>Consider an application that loads a large configuration object, lookup table, or machine-learning resource during startup. If the resource is not immediately required, eager initialisation may waste memory and increase startup time. A traditional approach might look like this:</p><pre>class Configuration {<br>    private static final Map&lt;String, String&gt; SETTINGS = loadSettings();<br>    static Map&lt;String, String&gt; getSettings() {<br>        return SETTINGS;<br>    }<br>}</pre><p>Here, the resource is initialised when the class is initialised.</p><p>Java developers have historically implemented lazy loading using techniques such as synchronised accessors, volatile fields, or initialisation-on-demand holder classes.</p><p>JDK 27 continues the development of a dedicated Lazy Constants API.</p><h4>What makes lazy constants interesting?</h4><p>The API is designed to combine controlled deferred initialisation with JVM optimisation opportunities associated with constant values.</p><p>Once initialised, the value behaves according to the API’s constant-value semantics rather than requiring developers to build their own initialisation framework.</p><h4>Potential use cases</h4><p>Lazy constants may be useful for:</p><ul><li>Expensive configuration data.</li><li>Large lookup tables.</li><li>Resource-intensive application components.</li><li>AI model-related metadata.</li><li>Rarely used application features.</li><li>Startup-sensitive services.</li></ul><p>For cloud-native applications, reduced initialisation work can improve startup behaviour and resource efficiency. However, benefits depend on how the application initialises and uses its data.</p><p><strong>My takeaway:</strong> Lazy constants address an old Java problem with a more deliberate API. The interesting part is not the concept of laziness itself, but how the JVM can optimise and reason about the resulting values.</p><h3>7. Vector API: Bringing High-Performance Data Processing to Java</h3><p>Java is often associated with backend business applications. But modern workloads increasingly involve data processing, analytics, cryptography, scientific computing, and machine learning. These workloads frequently perform the same operation across large collections of numbers.</p><p>For example:</p><pre>for (int i = 0; i &lt; values.length; i++) {<br>    values[i] = values[i] * 2;<br>}</pre><p>This is a scalar-style computation, expressing one array element at a time. Modern CPUs support SIMD, or Single Instruction, Multiple Data, operations. SIMD instructions can process several values simultaneously. The Vector API allows Java developers to express vector computations that the JVM can map to efficient CPU instructions on supported hardware.</p><h4>Why is this significant?</h4><p>It provides a way to write high-performance numeric operations in Java without relying entirely on manually written native code.</p><p>Potential applications include:</p><ul><li>Machine-learning inference.</li><li>Image processing.</li><li>Scientific simulations.</li><li>Financial calculations.</li><li>Statistical analysis.</li><li>Signal processing.</li></ul><p>The API is particularly interesting for applications that process large numerical datasets.</p><h4>Does the Vector API automatically make every application faster?</h4><p>No.</p><p>Performance depends on the CPU architecture, data layout, operation type, compiler optimisations, and workload characteristics. JVM auto-vectorisation already optimises certain loops, so explicit vector code is not always necessary. The Vector API gives developers greater control where benchmarks justify it. It remains an incubating feature in JDK 27 and is not yet a finalised Java SE API.</p><h3>8. PEM Encoding API: Simplifying Cryptographic Integration</h3><p>Security-focused Java applications frequently need to work with certificates and cryptographic keys. These objects are often represented using PEM, short for Privacy-Enhanced Mail. You have probably seen PEM-formatted data before:</p><pre>-----BEGIN CERTIFICATE-----<br>MIIB...example-content...<br>-----END CERTIFICATE-----</pre><p>PEM uses a familiar textual envelope around Base64-encoded binary data. Historically, working with PEM formats in Java could involve additional conversion logic or third-party libraries. JDK 27 continues developing an API for encoding and decoding cryptographic objects using PEM.</p><h4>What does this improve?</h4><p>The API aims to simplify interoperability between Java security objects and commonly used cryptographic file formats.</p><p>It supports use cases involving:</p><ul><li>Public and private keys.</li><li>Digital certificates.</li><li>Certificate revocation lists.</li><li>Security configuration.</li><li>Cryptographic integrations.</li></ul><p>This is especially useful in enterprise environments where Java applications communicate with external systems built using different programming languages and security tools. Standardising these operations can reduce repetitive conversion code and avoid some common implementation mistakes. As with other preview APIs, developers should account for possible API changes in later Java releases.</p><h3>9. JFR In-Process Data Redaction: Safer Production Diagnostics</h3><p>Java Flight Recorder, commonly known as JFR, is one of the most valuable JVM observability tools. It allows engineering teams to investigate application performance and runtime behaviour.</p><p>JFR can capture information about:</p><ul><li>CPU activity.</li><li>Memory allocation.</li><li>Garbage collection.</li><li>Thread execution.</li><li>JVM events.</li><li>Application performance characteristics.</li></ul><p>However, diagnostic recordings may contain sensitive runtime information.<em> For example</em>, command-line arguments and environment variables sometimes contain credentials, configuration secrets, or internal connection details. That creates a security concern when recordings are shared across engineering teams or uploaded into diagnostic systems.</p><h4>What Java 27 introduces</h4><p>JEP 536 enhances JFR with in-process redaction of command-line arguments and the initial values of environment variables and system properties. The sensitive information is redacted before the recording leaves the process.</p><h4>Why does it matter?</h4><p>Imagine a production incident involving a critical Java microservice. Engineers collect a JFR recording and share it with developers, platform engineers, or a support provider. Without appropriate protections, diagnostic data could reveal sensitive configuration.</p><p>In-process redaction reduces that particular exposure risk. It does not mean that every possible application secret or sensitive payload recorded through JFR is automatically protected. Organisations still need sensible diagnostic access controls, data-handling rules, and secret-management practices. For production engineering teams, this is a valuable improvement because effective troubleshooting should not introduce unnecessary security risks.</p><h3>Additional JVM and Developer Tooling Improvements</h3><p>The nine JEPs are the headline features, but Java 27 includes other improvements worth understanding.</p><h4>Better cryptographic performance</h4><p>JDK 27 includes performance and implementation improvements affecting cryptographic algorithms such as ML-KEM, ML-DSA, X25519, and Ed25519. These changes are relevant to secure communication, digital signatures, and cryptographic key management.</p><h4>Improved security diagnostics</h4><p>A new jcmd diagnostic capability allows engineers to inspect active JVM security properties. For example:</p><pre>jcmd &lt;pid&gt; VM.security_properties</pre><p>This can help teams investigate runtime security configuration rather than relying only on configuration files.</p><h4>Improved JVM diagnostics</h4><p>Java 27 also improves runtime observability with enhancements such as reporting open file descriptors. This can help investigate issues involving resource exhaustion and file-handle leaks.</p><h4>More machine-readable thread dumps</h4><p>JSON thread dumps now represent relevant identifiers and counts as JSON numbers. This may sound like a minor detail, but it makes parsing and integration easier for monitoring tools and incident-response automation. For SRE and platform teams, such improvements can be genuinely useful.</p><h4>Performance improvements beyond the major JEPs</h4><p>JDK 27 also includes work across:</p><ul><li>G1 heap sizing.</li><li>JIT compiler optimisations.</li><li>Vector processing.</li><li>File and native I/O.</li><li>JVM runtime efficiency.</li></ul><p>As always, the practical impact will depend on the application and deployment environment.</p><h3>Java 27 vs Java 25 LTS: Which Should You Choose?</h3><h4>When should you choose Java 25?</h4><p>Java 25 is a sensible choice when your organization prioritizes:</p><ul><li>Long-term vendor support.</li><li>Production stability.</li><li>Predictable maintenance.</li><li>Enterprise framework compatibility.</li><li>A slower upgrade schedule.</li></ul><h4>When should you choose Java 27?</h4><p>Java 27 is worth considering when:</p><ul><li>You actively track Java releases.</li><li>You want to benchmark new JVM improvements.</li><li>You are building or testing applications that may benefit from new APIs.</li><li>You need to evaluate post-quantum TLS capabilities.</li><li>Your engineering team can manage regular JDK upgrades.</li></ul><p>There is no universal answer. Some organisations benefit from adopting feature releases quickly. Others are better served by standardising on an LTS version. T<em>he right decision depends on application criticality, dependency compatibility, support requirements, and operational readiness.</em></p><h3>Migration Checklist: Moving Existing Applications to Java 27</h3><p>Upgrading Java is not just about installing a newer JDK. For production systems, migration should be approached as an engineering change.</p><h4>Step 1: Check framework compatibility</h4><p>Validate your application’s dependencies, including:</p><ul><li>Spring Boot and Spring Framework.</li><li>Hibernate and persistence libraries.</li><li>Maven or Gradle.</li><li>Logging frameworks.</li><li>Application servers.</li><li>Observability agents.</li><li>Bytecode manipulation libraries.</li></ul><p>Do not assume every framework or library officially supports Java 27 immediately.</p><h4>Step 2: Review JVM configuration</h4><p>Check existing garbage collector settings, heap configuration, JVM startup arguments, and memory limits. Because Java 27 changes default garbage collection and object-header behaviour, comparing runtime characteristics is especially important.</p><h4>Step 3: Benchmark performance</h4><p>Compare existing and upgraded versions using equivalent workloads. Useful measurements include:</p><ul><li>Application startup time.</li><li>Heap consumption.</li><li>CPU utilisation.</li><li>Garbage collection pauses.</li><li>Request latency.</li><li>Throughput.</li><li>Container memory usage.</li></ul><p>Where possible, use realistic traffic and representative datasets.</p><h4>Step 4: Review reflection-related warnings</h4><p>Java 27 issues warnings for certain attempts to mutate final fields through deep reflection. This is part of Java’s longer-term effort to strengthen integrity by default. Applications that rely on reflective field mutation, directly or through dependencies, should investigate these warnings before future restrictions are introduced.</p><h4>Step 5: Validate TLS and cryptographic integration</h4><p>For applications handling secure communication, test certificate handling, supported TLS configurations, cryptographic providers, and compatibility with external endpoints. This becomes especially important when introducing newer post-quantum capabilities.</p><h4>Step 6: Validate production observability</h4><p>Confirm that JFR, profiling tools, monitoring agents, log collectors, and thread-dump automation continue to work as expected.</p><h4>Step 7: Use a controlled rollout</h4><p>For business-critical applications, consider:</p><ul><li>Canary releases.</li><li>Blue-green deployments.</li><li>Feature-specific testing.</li><li>Controlled traffic migration.</li><li>Explicit rollback procedures.</li></ul><p>A successful compilation does not guarantee identical runtime behaviour.</p><h3>What Java 27 Means for Spring Boot and Microservices Developers</h3><p>For many backend engineers, the most important question is not what Java 27 introduces, but how the changes affect everyday development.</p><p>Imagine a microservices platform processing thousands of requests per second. It runs multiple Java services responsible for authentication, customer information, transactions, notification delivery, and reporting. Java 27 may offer improvements in several areas.</p><p><strong>Memory utilisation:</strong> Compact object headers can reduce heap overhead, especially for applications with large numbers of small objects.</p><p><strong>Garbage collection:</strong> Consistent G1 defaults can simplify runtime behaviour across different deployment environments.</p><p><strong>Concurrency:</strong> Structured concurrency provides a clearer model for managing groups of related operations, although it remains a preview feature.</p><p><strong>Security:</strong> Post-quantum hybrid key exchange strengthens Java’s ability to support future-facing secure communication.</p><p><strong>Observability:</strong> JFR improvements and additional diagnostic capabilities make production investigation more practical.</p><p><strong>Performance:</strong> JVM and compiler improvements may reduce processing overhead in selected workloads.</p><p>These changes are not a promise that every Spring Boot application will immediately become faster after upgrading. But they create opportunities to improve efficiency and maintainability without redesigning an entire system. And that is where modern Java is particularly strong.</p><h3>The Bigger Picture: Java’s Future Is Not Just About Syntax</h3><p>One interesting thing about Java’s recent evolution is that the platform increasingly focuses on infrastructure-level improvements. Of course, language features remain important. But major production challenges are not always solved by introducing new syntax.</p><p>They are often solved by improving the runtime itself. Reducing object overhead can lower memory consumption. Improving garbage collection can create more predictable application behaviour. Making concurrency easier to manage can reduce operational complexity. Strengthening cryptographic capabilities can help organisations prepare for emerging security threats. Improving observability can shorten production investigations.</p><p>This is what makes Java 27 noteworthy. It is not trying to replace everything developers already know. Instead, it continues refining the platform on which millions of applications depend.</p><h3>Final Thoughts: Is Java 27 Worth Your Attention?</h3><p>Absolutely.</p><p>But paying attention to Java 27 does not necessarily mean upgrading every production application immediately. The real value of this release is understanding where Java is heading. Compact object headers show how deeply the JVM continues to evolve. Structured concurrency reflects the platform’s effort to make asynchronous and concurrent programming more manageable. Post-quantum hybrid key exchange demonstrates that Java is preparing for security challenges that may become increasingly relevant over the coming years. Lazy constants and the Vector API expand the possibilities for resource-efficient and computationally intensive applications. And improvements to JFR and runtime diagnostics show that operational experience remains a priority.</p><p>For developers, my recommendation is straightforward:</p><p><strong>Use Java 27 to learn, experiment, and benchmark. Use an appropriate supported LTS release when long-term production stability is the priority.</strong></p><p>Java does not need to reinvent itself with every release. It needs to keep becoming better at what it already does exceptionally well: powering reliable, scalable, and long-lived software systems. Java 27 is another important step in that journey. And with JDK 29 LTS on the horizon, the next chapter of Java development looks particularly interesting.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8b5d4fd8ed6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Turning Claude into an Expert Agent: A Guide to Building Custom Skills]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">If you&#x2019;ve used GitHub Copilot or Claude Code recently, you might have noticed a shift. We are moving away from passive &#x201C;copilots&#x201D; that&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/turning-claude-into-an-expert-agent-a-guide-to-building-custom-skills-5f8157c83151?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/turning-claude-into-an-expert-agent-a-guide-to-building-custom-skills-5f8157c83151?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f8157c83151</guid>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[skills]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 09:19:19 GMT</pubDate>
            <atom:updated>2026-08-23T09:20:23.013Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Understanding Postgres WAL: What It Is and How It Works]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@reetesh043/understanding-postgres-wal-what-it-is-and-how-it-works-7653abca244f?source=rss-859db09d6506------2"><img src="https://cdn-images-1.medium.com/max/1370/1*6Ha6nmQzVy_yCXAoSteKUg.png" width="1370"></a></p><p class="medium-feed-snippet">Every time I&#x2019;ve had to explain a production Postgres incident, a replica falling behind, a disk filling up with pg_wal segments, or a&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/understanding-postgres-wal-what-it-is-and-how-it-works-7653abca244f?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/understanding-postgres-wal-what-it-is-and-how-it-works-7653abca244f?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/7653abca244f</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[aws-aurora]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[database-design]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Sat, 11 Jul 2026 09:19:58 GMT</pubDate>
            <atom:updated>2026-07-11T09:19:58.803Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Using AWS Secrets Manager in Spring Boot]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@reetesh043/using-aws-secrets-manager-in-spring-boot-ea5138285e31?source=rss-859db09d6506------2"><img src="https://cdn-images-1.medium.com/max/1440/1*LE9IeepaWT_BI86i86TM6g.png" width="1440"></a></p><p class="medium-feed-snippet">If you&#x2019;ve been managing secrets in Spring Boot the old way, injecting a SecretsManagerClient bean, calling getSecretValue() yourself, and&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/using-aws-secrets-manager-in-spring-boot-ea5138285e31?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/using-aws-secrets-manager-in-spring-boot-ea5138285e31?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea5138285e31</guid>
            <category><![CDATA[aws-secrets-manager]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[spring-framework]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 15:56:35 GMT</pubDate>
            <atom:updated>2026-07-05T15:56:35.423Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Java is Having Its AI moment, and nobody saw it coming]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@reetesh043/java-is-having-its-ai-moment-and-nobody-saw-it-coming-75a6c348536b?source=rss-859db09d6506------2"><img src="https://cdn-images-1.medium.com/max/1214/1*p2GUqyUlEhn18fHfSoPGcQ.png" width="1214"></a></p><p class="medium-feed-snippet">For years, Python owned the AI conversation. That&#x2019;s quietly changing.</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/java-is-having-its-ai-moment-and-nobody-saw-it-coming-75a6c348536b?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/java-is-having-its-ai-moment-and-nobody-saw-it-coming-75a6c348536b?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/75a6c348536b</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[spring-ai]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Sat, 30 May 2026 18:53:56 GMT</pubDate>
            <atom:updated>2026-05-30T18:53:56.226Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[RAG vs. Agents: Which AI Architecture Should You Actually Use?]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@reetesh043/rag-vs-agents-which-ai-architecture-should-you-actually-use-fd3ea4860264?source=rss-859db09d6506------2"><img src="https://cdn-images-1.medium.com/max/1238/1*kb9S6kKMaDyJ04LikVfKMA.png" width="1238"></a></p><p class="medium-feed-snippet">There&#x2019;s a question that comes up in almost every AI engineering conversation right now:</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/rag-vs-agents-which-ai-architecture-should-you-actually-use-fd3ea4860264?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/rag-vs-agents-which-ai-architecture-should-you-actually-use-fd3ea4860264?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd3ea4860264</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Sat, 23 May 2026 21:07:18 GMT</pubDate>
            <atom:updated>2026-05-23T21:07:18.780Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[AWS Karpenter: The Node Autoscaler That Actually Understands Your Workloads]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@reetesh043/aws-karpenter-the-node-autoscaler-that-actually-understands-your-workloads-65564b891bcd?source=rss-859db09d6506------2"><img src="https://cdn-images-1.medium.com/max/1280/1*WQcFJhbrLuWdCd0AeB_C0g.png" width="1280"></a></p><p class="medium-feed-snippet">If you&#x2019;ve ever stared at a Kubernetes cluster silently sitting on over-provisioned nodes or worse, watched pods languish in a Pending&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/aws-karpenter-the-node-autoscaler-that-actually-understands-your-workloads-65564b891bcd?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/aws-karpenter-the-node-autoscaler-that-actually-understands-your-workloads-65564b891bcd?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/65564b891bcd</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[scaling-with-karpenter]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Wed, 08 Apr 2026 06:01:01 GMT</pubDate>
            <atom:updated>2026-04-08T06:01:01.432Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Terramate: Managing Terraform at Scale Without Losing Your Mind]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@reetesh043/terramate-managing-terraform-at-scale-without-losing-your-mind-b9a3d5621e96?source=rss-859db09d6506------2"><img src="https://cdn-images-1.medium.com/max/1292/1*z9TggMBpB7skW4-yLF7ykQ.png" width="1292"></a></p><p class="medium-feed-snippet">If you&#x2019;ve ever worked on a large infrastructure codebase powered by Terraform, you&#x2019;ve probably felt the pain: dozens of stacks, repetitive&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/terramate-managing-terraform-at-scale-without-losing-your-mind-b9a3d5621e96?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/terramate-managing-terraform-at-scale-without-losing-your-mind-b9a3d5621e96?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9a3d5621e96</guid>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[terramate]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Tue, 07 Apr 2026 06:31:01 GMT</pubDate>
            <atom:updated>2026-04-07T06:31:01.419Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Beyond the Origin: Solving the Global Latency Puzzle]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@reetesh043/beyond-the-origin-solving-the-global-latency-puzzle-9800af0b51b7?source=rss-859db09d6506------2"><img src="https://cdn-images-1.medium.com/max/2488/1*iV0pqj_OkAYcOHAt2IZNGg.png" width="2488"></a></p><p class="medium-feed-snippet">Same code. Same backend. Same database. Yet users 9,000 miles away are staring at a spinner.</p><p class="medium-feed-link"><a href="https://medium.com/@reetesh043/beyond-the-origin-solving-the-global-latency-puzzle-9800af0b51b7?source=rss-859db09d6506------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@reetesh043/beyond-the-origin-solving-the-global-latency-puzzle-9800af0b51b7?source=rss-859db09d6506------2</link>
            <guid isPermaLink="false">https://medium.com/p/9800af0b51b7</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cdn]]></category>
            <category><![CDATA[web-performance]]></category>
            <category><![CDATA[system-design-interview]]></category>
            <dc:creator><![CDATA[Reetesh Kumar]]></dc:creator>
            <pubDate>Tue, 03 Mar 2026 06:01:00 GMT</pubDate>
            <atom:updated>2026-03-03T06:01:00.612Z</atom:updated>
        </item>
    </channel>
</rss>