Jonathan Lalou's Blog

Posts Tagged ‘AgenticAI’

Lecturer

Hang Celia is a developer advocate at Amazon Web Services (AWS) based in Hong Kong, specializing in AI and robotics integrations. Saras Wang is a senior AWS Hero from Hong Kong, actively contributing to social media platforms and community discussions on cloud technologies.

Abstract

This article investigates the integration of voice control with agentic AI for managing humanoid robots, robot dogs, and drones, drawing from a collaborative project with the Hong Kong Institute of Information Technology (HKIIT). It examines the architecture for low-latency command processing, intent recognition, and responsive behaviors, while analyzing methodologies for handling continuous speech and multi-robot coordination, along with their broader implications for real-world applications.

Overview of Agentic AI and Its Future Predictions

Agentic AI marks a significant advancement in the field of artificial intelligence, shifting from passive response systems to proactive entities capable of independent planning, decision-making, and execution of complex tasks in dynamic settings. Hang Celia sets the stage by drawing on insights from leading investment analyses, which project a profound impact on various industries. For example, Goldman Sachs anticipates that by 2027, agentic AI could automate as much as 25% of routine work activities, thereby reshaping labor markets and boosting productivity across sectors. Similarly, McKinsey’s projections suggest that by 2030, this technology might account for 30% of current work hours, highlighting its potential to revolutionize operational efficiencies, especially in areas demanding real-time adaptability such as automated systems and robotics.

Building on these forecasts, agentic AI extends beyond traditional large language models by incorporating advanced capabilities like logical reasoning, external tool integration, and iterative problem-solving over multiple stages. Hang illustrates this evolution through practical demonstrations, where an agent might receive a natural language command, break it down into actionable components, query external resources via APIs, and refine its approach based on ongoing feedback. This stands in stark contrast to earlier AI paradigms, which were largely reactive and limited to single-turn interactions, and instead positions agentic systems as versatile facilitators for sophisticated human-machine collaborations, particularly in controlling physical devices like robots.

The underlying methodology for deploying agentic AI in such contexts relies heavily on cloud-based services, with AWS offerings like Amazon Bedrock providing the orchestration layer that enables seamless access to knowledge repositories and function executions. This not only facilitates rapid prototyping but also ensures that the systems can scale to handle diverse inputs and outputs. Consequently, the implications are far-reaching, as agentic AI holds the promise of making advanced robotic controls more intuitive and widespread, extending their utility from specialized research environments to everyday applications in homes, offices, and industrial facilities.

Architecture for Voice-Controlled Robotics

The architectural design of the voice-controlled robotics system is engineered to support seamless and natural interactions, combining speech processing, natural language comprehension, and agentic execution to achieve responses with minimal delay and maximal accuracy. Saras Wang provides a detailed walkthrough of the system’s structure, which harnesses a suite of AWS services to transform spoken commands into precise directives for a variety of robots, including humanoids, quadruped models, and aerial drones. At its core, the setup begins with Amazon Transcribe, which converts audio streams into text in real time, enabling the system to interpret ongoing conversations without requiring artificial pauses or structured phrasing.

From there, the processed text feeds into Amazon Bedrock, where intent detection occurs, identifying the user’s objectives and mapping them to specific robot functions. This integration allows for flexible handling of commands, such as directing a humanoid to perform a gesture while simultaneously instructing a drone to adjust its position. Saras emphasizes the importance of WebSockets in maintaining bidirectional communication channels, which facilitate not only command issuance but also feedback loops from the robots, ensuring that the system can adapt to changing conditions or confirm task completions.

In terms of methodology, the approach prioritizes optimization for diverse environments, incorporating noise-reduction algorithms to filter out background interference and edge computing elements to minimize latency in transmission. Challenges like varying accents or ambiguous phrasing are addressed through machine learning models trained on extensive datasets, which refine recognition over time. Overall, this architecture enhances usability by making robotic control as intuitive as everyday speech, while its modular design supports expansions to new device types or additional functionalities without overhauling the core framework.

Multi-Robot Coordination and Parallel Execution

Coordinating actions across multiple robots introduces layers of complexity in terms of synchronization and resource allocation, yet the project demonstrates effective solutions through strategic function calling and API optimizations that enable simultaneous operations. Hang elaborates on how agentic AI can trigger parallel invocations, allowing a single voice command to engage several devices without sequential bottlenecks. For instance, a directive to have all robots rotate could be decomposed, with the agent assigning unique tasks to each unit—perhaps turning one left, another right, and a third forward—while ensuring no conflicts in shared spaces.

Saras offers practical code insights to illustrate this parallelism:

import concurrent.futures

def control_robot(robot_id, action):
    '''# API call to robot'''
    response = robot_api.execute(robot_id, action)
    return response

with concurrent.futures.ThreadPoolExecutor() as executor:
    future1 = executor.submit(control_robot, 'robot1', 'turn_left')
    future2 = executor.submit(control_robot, 'robot2', 'move_forward')
    results = [future1.result(), future2.result()]

This code leverages threading to execute commands concurrently, significantly reducing overall response times. The methodology involves designing robot APIs to support asynchronous calls, with AWS Lambda or similar services handling orchestration to distribute loads evenly. In real-world contexts, this prevents overloads during high-demand scenarios, such as coordinated search operations with drones and ground robots.

The implications for scalability are substantial, as this framework can extend to fleets of dozens or hundreds of units, applicable in logistics warehouses or disaster response teams. By prioritizing parallel processing, the system not only improves efficiency but also enhances reliability, as failures in one robot do not halt the entire operation.

Challenges, Innovations, and Real-World Implications

While the fusion of voice interfaces with agentic AI offers immense promise, it also surfaces obstacles like debugging intricate integrations and managing network dependencies, which the project overcomes through iterative innovations and tool leveraging. Saras reflects on initial hurdles: early attempts avoided frameworks for perceived simplicity, but this led to unresolved issues in error handling and scalability. Transitioning to structured frameworks, such as AWS CLI for API conversions, resolved these, underscoring the importance of utilizing pre-existing solutions to address common pitfalls without reinventing foundational elements.

Innovations include adapting request-response APIs to streaming formats for continuous dialogues, facilitated by Amazon Q’s automation capabilities. Hang notes experiments with digital humans, where APIs process multilingual documentation—such as simplified Chinese sources—via AI-driven implementations, broadening accessibility.

Broader real-world implications span from educational tools, where students command robots intuitively, to assistive technologies for the elderly, enhancing independence. Future enhancements might include office automation, where voice directives control devices seamlessly, transforming how humans interact with intelligent systems in daily life.

Conclusion

The HKIIT-AWS collaboration vividly demonstrates how agentic AI and voice control can elevate robotics to new levels of practicality and engagement. By tackling coordination challenges and harnessing AWS infrastructure, it establishes a foundation for innovative applications that bridge the gap between human intent and machine action.

Links:

• https://www.youtube.com/watch?v=ZKqV1Ok-2-c

Lecturer

Christoph Bühler is a Research Assistant at the University of St. Gallen, focusing on software engineering, programming languages, system security, and infrastructure as code. His work explores securing AI applications. Relevant links include his LinkedIn profile (https://ch.linkedin.com/in/christoph-b%C3%BChler-a3a262270) and institutional page (https://programming-group.com/members/buehler).

Abstract

This article investigates Christoph Bühler’s discourse on agentic AI security, spotlighting vulnerabilities in tools like Model Context Protocol (MCP). It analyzes risks from function calling, proposes permission-based controls, and evaluates efficiency. Encompassing industry trends, academic citations, and future behavior analysis, it underscores mitigation’s urgency.

The Ascent of Agentic AI and Emerging Vulnerabilities

Christoph traces AI’s rapid evolution, from OpenAI’s valuation surge to widespread developer adoption, as evidenced by surveys and citations of foundational papers. The shift to agentic systems, where LLMs interact via tools and MCP—a JSON-RPC interface—marks a pivotal change. This enables dynamic actions but introduces risks, as agents inherit full user privileges. Real-world incidents, such as database deletions or drive wipes, illustrate how unchecked agents can cause harm. Contexts include the non-deterministic nature of LLMs, complicating safeguards, and prompt injections exploiting natural language weaknesses. The implications are severe, eroding trust and exposing systems to exploits that deterministic tools might prevent.

Permission-Based Controls as a Foundational Mitigation

To address these, Christoph proposes encapsulating MCP servers with permission-based access controls, akin to mobile app permissions. Developers define capabilities—file read/write, network domains—ensuring agents operate within bounds. This deterministic layer confines executions, blocking unauthorized accesses like SSH key theft. The methodology wraps servers in Docker, mapping policies to runtime constraints, with minimal overhead (0.6ms). Contexts involve compatibility with existing MCP implementations, allowing seamless adoption. The implications enhance safety without sacrificing functionality, providing a practical barrier against non-deterministic behaviors.

Extending Mitigation Through Behavior Analysis

Christoph outlines future directions, including runtime isolation for behavior analysis. Agents run unrestricted, with post-execution assessments distinguishing benign from malicious actions. This helps predict risks from prompt-agent interactions, aiding practitioners in safeguarding applications. Contexts draw from malware detection traditions, adapting them to AI’s unique challenges. The implications offer proactive tools for threat anticipation, complementing permission controls in a comprehensive security strategy.

Broader Ramifications for AI Governance

The talk emphasizes confining AI to avert historical errors like viruses. By prioritizing transparency and controls, developers can harness agentic potential responsibly. The contexts reflect industry hype outpacing security, necessitating balanced approaches. The implications advocate for human-centric governance, ensuring AI augments rather than endangers.

Links:

• Lecture Video
• Christoph Bühler on LinkedIn
• University of St. Gallen Programming Group

Lecturers
Dimitris Papageorgiou and Konstantina Mavrodimitraki are Senior Solutions Architects at Amazon Web Services in Greece. With extensive experience as software and data engineers, they have supported numerous enterprise customers in adopting cloud-native and AI technologies. Their work focuses on practical implementation strategies that deliver measurable business value while addressing real-world concerns around quality, security, and team readiness.

Abstract
Dimitris Papageorgiou and Konstantina Mavrodimitraki present a pragmatic framework for integrating agentic AI into software development lifecycles. Based on hands-on implementations across multiple customer environments, the session addresses common barriers such as code quality fears, lack of structure, and resistance to change. Through concrete examples—including optimized code reviews returning over 16,000 developer hours annually and 65-80% faster issue resolution—they outline a phased approach from individual experimentation to cross-team standardization and organizational scaling.

The Current State of AI Adoption in Development Teams

Many organizations purchase AI tool licenses and distribute them broadly, expecting immediate productivity gains. In practice, developers experiment individually—often engaging in “vibe coding”—without shared practices or metrics. This leads to fragmented adoption, inconsistent quality, and difficulty demonstrating return on investment to leadership.

The speakers identify a critical gap: while tools proliferate, teams lack a common language and structured methodology. Success requires moving beyond ad-hoc usage to deliberate integration aligned with specific pain points.

A Framework for Systematic Agentic AI Adoption

The proposed framework operates along two dimensions: organizational pain points and AI maturity levels. Pain points—such as code review bottlenecks, testing coverage, or feature development velocity—must be identified first. Maturity progresses from individual experimentation to team standardization and finally cross-team integration.

Teams begin at their current maturity level and implement solutions appropriate to that stage. For code review bottlenecks, level-one teams conduct structured experimentation with various tools, followed by retrospectives to select winners. Level-two teams document guidelines, define success metrics, and establish processes. Level-three organizations embed AI into pipelines with shared patterns and governance.

Applying the Framework: Code Reviews and Testing

For code reviews, a real-world AWS customer in betting and gaming implemented an agentic workflow using Amazon Bedrock. Pull request events trigger enrichment via data pipelines before an agent analyzes changes against coding standards, security rules, and business requirements. The system posts comments directly, with optional human validation.

Metrics showed over 16,700 developer hours returned annually, allowing focus on higher-value work. Similar patterns apply to testing: starting with AI-assisted unit test generation, teams progress to standardized pipelines and shared test patterns across the organization.

Feature Development with Spec-Driven Approaches

Spec-driven development extends AI assistance across the lifecycle. Rather than isolated prompts, teams collaborate with agents to refine requirements, architectural decisions, and task breakdowns. Amazon Q Developer exemplifies this, generating user stories, acceptance criteria, designs, and implementation tasks from high-level intents.

This approach reduces back-and-forth during sprint planning and ensures generated code aligns with broader context. Workshops help teams adapt the process to their needs, fostering ownership and continuous improvement.

Scaling and Avoiding Common Pitfalls

Successful scaling requires executive sponsorship, dedicated time for experimentation, and clear metrics. Leadership must treat AI adoption as a strategic initiative rather than a side project. Engineers should share learnings and metrics to build momentum.

Pitfalls include unstructured experimentation leading to technical debt, over-reliance on AI without human oversight, and failure to measure impact. The speakers recommend divide-and-conquer: tackle one pain point thoroughly before expanding.

Conclusion: AI as a Multiplier of Good Practices

Agentic AI amplifies existing strengths in clean code, testing, documentation, and collaboration. By following a pragmatic, maturity-aligned path, teams achieve faster delivery, higher quality, and greater developer satisfaction. The framework transforms AI from a hype-driven experiment into a structured capability delivering tangible results.

Links:

• Video: The Pragmatic Path

Lecturer

Santiago Giraldo serves as Senior Director of Product Marketing for Artificial Intelligence at Snowflake. With over 15 years of experience in data and AI technology, Santiago specializes in bridging business needs with advanced technical solutions, focusing on generative AI and enterprise data platforms. He holds a background from Parsons School of Design – The New School and is based in the Denver Metropolitan Area.

Brian Neumann is Senior Vice President of Engineering at Decile, an e-commerce analytics platform. Brian leads engineering efforts to develop innovative data solutions for brands, emphasizing multi-tenant architectures and AI integration to enhance customer insights.

Abstract

This presentation explores the transformative potential of Snowflake Intelligence, a generative AI-powered feature set designed to enable natural language interactions with enterprise data. Santiago introduces the core principles of Snowflake Intelligence, addressing longstanding challenges in data accessibility and decision-making velocity. Brian then details Decile’s implementation, showcasing how the platform powers Luma, a custom AI analyst that democratizes e-commerce insights across organizational roles. The discussion highlights architectural strategies, trust mechanisms, and practical outcomes, illustrating how agentic AI can shift enterprises from reactive reporting to proactive, reasoned action.

Bridging the Gap Between Business and Data Teams

Enterprises often grapple with disparities in how business users and data teams interact with information. Business stakeholders require timely, actionable insights to drive decisions, yet data teams frequently dedicate substantial effort to producing static reports or dashboards. By the time these deliverables reach decision-makers, opportunities may have diminished, as insights arrive too late for effective intervention.

Snowflake Intelligence addresses this divide by empowering users—from executives to frontline employees—to pose complex questions in natural language and receive reasoned responses. Unlike traditional tools limited to surface-level queries (e.g., “What were sales last week?”), this innovation facilitates deeper inquiry, such as identifying underlying causes or forecasting future trends. It integrates data from disparate sources, including databases, customer platforms like Salesforce, and third-party enrichments, all within a secure, governed environment.

A key advantage lies in its enterprise readiness: features are native to the Snowflake platform, ensuring robust governance, security, and data quality. This approach fosters a “reasoning partner” dynamic, where AI not only retrieves data but also provides explanatory context, enabling high-confidence decisions in real time.

Core Principles and Capabilities of Snowflake Intelligence

Snowflake Intelligence rests on three foundational pillars: deep analysis, trust, and enterprise-grade security.

Deep analysis extends beyond descriptive reporting to prescriptive and predictive reasoning. Users can explore questions like “What headwinds threaten upcoming sales?” or “How can retention be improved?” by leveraging multimodal data—structured and unstructured—across the organization. Features such as research mode enable forward-looking investigations, drawing from comprehensive knowledge sources.

Trust is paramount in generative AI adoption, where hallucinations or opaque reasoning erode confidence. Snowflake mitigates this through verified answers, full traceability to original sources, and transparent explanations. Responses include reformulated queries, step-by-step reasoning, and direct links to underlying SQL, allowing verification down to individual data points.

Enterprise readiness ensures all operations occur within Snowflake’s governed ecosystem. Dynamic discovery provides clear explanations of results, while integrations with marketplace data and enterprise tools unify insights. This holistic design transforms data utilization, placing organizational knowledge at users’ fingertips for instantaneous, reliable exploration.

Decile’s Journey: From Traditional Analytics to AI-Driven Insights

Decile operates as an e-commerce analytics platform, serving over 100 leading brands by aggregating data from sources like Shopify, Magento, marketing channels, and enrichment providers such as Acxiom. The platform creates dedicated Snowflake data warehouses per client, overlaid with application experiences for lifecycle reporting and customer segmentation.

Initially, Decile’s dashboards aimed to surpass native platform reporting by stitching disparate data for richer views. However, brand variability—ranging from retail integrations to diverse product analytics—complicated dashboard flexibility. This led to increased complexity for non-technical users, who grew reliant on customer success teams, effectively positioning Decile as an outsourced data function.

Recognizing this barrier, Decile sought to empower clients directly through an AI analyst. Early prototyping with various frameworks revealed significant hurdles: building vector stores for semantic understanding, ensuring SQL accuracy, providing visualizations, and establishing evaluation mechanisms. These challenges posed substantial investment risks for a startup.

Snowflake Intelligence emerged as an ideal solution, leveraging existing governed warehouses and dbt semantic models. Implementation involved extending dbt documentation with metadata (aliases, synonyms, sample values) to inform semantic views—YAML-defined structures describing dimensions, measures, relationships, and natural language descriptions.

Cortex Search services enhanced fuzzy matching for free-form queries, while verified queries predefined complex calculations (e.g., retention cohorts). A custom library automated provisioning of semantic views, search services, and agents via deployment pipelines.

Implementation Outcomes and Future Directions at Decile

Rapid deployment enabled pilot testing through Snowflake’s UI, gathering feedback to refine models. API access facilitated seamless integration into Decile’s application, branding the experience as Luma—a conversational AI analyst.

Users reported substantial time savings, with marketers and executives conducting analyses previously requiring extensive report stitching. Visible thinking steps—detailing semantic mappings and reasoning—built confidence, reducing perceived black-box risks. Support queries dropped 75% among adopters, as users self-served segments for activation.

Luma’s impact extends to operational efficiency: quicker market entry, reduced custom report demands, and empowered segmentation (e.g., identifying repeat purchasers for subscriptions).

Looking ahead, Decile plans per-brand instruction customization to capture nuances (e.g., subscription vendors, wholesale handling). Aspirations include user-contributed context for vertical-specific analyses and scheduled alerting for anomalies, emulating a proactive human analyst.

Implications for Enterprise AI Adoption

This collaboration exemplifies how Snowflake Intelligence lowers barriers to agentic AI in specialized domains. By providing turnkey frameworks—semantic views, APIs, and observability—platforms like Decile accelerate innovation without prohibitive development overhead.

Broader implications include democratized data access, reducing silos and delays while upholding trust through traceability. For e-commerce, this translates to agile responses to market dynamics, personalized strategies, and sustained growth.

Ultimately, such integrations signal a shift toward AI-augmented workflows, where tools complement human expertise, fostering cultures of data-driven agility and innovation.

Links:

• Lecture Video on YouTube
• Decile Company Website
• Luma AI by Decile
• Santiago Giraldo on LinkedIn

Lecturer

Abhijit Chakravarty, Mike Bechtel, and Michael J. Kavis
Abhijit Chakravarty is a seasoned technology leader at LogicMonitor, focusing on the intersection of artificial intelligence and infrastructure monitoring. Mike Bechtel serves as the Chief Futurist at Deloitte Consulting LLP, where he leads research into emerging technologies and their long-term impact on the enterprise. Michael J. Kavis is a Managing Director at Deloitte Consulting and a renowned expert in cloud computing and enterprise architecture, having authored multiple books on cloud transformation. Together, they represent a convergence of industry-leading monitoring solutions and strategic advisory expertise, specifically targeted at preparing global organizations for the complexities of the agentic AI era.

Abstract

As enterprise IT environments grow in scale and complexity, traditional AIOps frameworks—which primarily focused on pattern recognition and anomaly detection—are evolving into “Agentic AIOps.” This article explores the conceptual transition from systems that merely observe and alert to autonomous agents capable of reasoning, planning, and executing remediation tasks. By examining the integration of Large Language Models (LLMs) with operational telemetry, the study highlights a methodology centered on reducing “mean time to repair” (MTTR) and minimizing human intervention in repetitive incident management cycles. The analysis delves into the maturity model for agentic adoption, the necessity of rigorous data grounding, and the evolving role of the human operator in a supervised autonomous ecosystem. The findings suggest that agentic AIOps is not merely an efficiency tool but a fundamental redesign of IT governance and service reliability.

The Conceptual Evolution: From Observability to Autonomy

The IT landscape has historically progressed through distinct phases of monitoring. Early systems were reactive, relying on static thresholds to trigger alerts. This gave way to the first generation of AIOps, which utilized machine learning for event correlation and root cause analysis. However, even these advanced systems remained largely “human-in-the-loop,” where the AI identified a problem, but a person had to decide and act on the solution.

Agentic AIOps represents a paradigm shift where the AI moves from an advisor to a doer. Unlike traditional automation, which follows a rigid, pre-defined script (e.g., “if X, then do Y”), agentic systems utilize the reasoning capabilities of LLMs to handle “non-deterministic” scenarios. These agents can interpret natural language incident reports, query multiple databases to gather context, and generate a step-by-step remediation plan that adapts to the specific nuances of the failure.

Methodology: Reasoning, Tool-Use, and Grounding

The architecture of a modern agentic AIOps system, such as LogicMonitor’s “Edwin AI,” relies on three core pillars: reasoning, tool-use, and grounding.

Strategic Reasoning and Planning

The “brain” of the agent is the LLM, which processes incoming alerts through a reasoning framework—often employing the “ReAct” (Reason + Act) pattern. When an incident occurs, the agent first decomposes the problem into smaller, manageable sub-tasks. It formulates a hypothesis about the root cause and identifies the necessary information required to validate that hypothesis.

Dynamic Tool-Use

To act on its reasoning, the agent must be able to interact with the environment. This is achieved through “function calling” or tool-integration. An agent might have access to a suite of tools, including:

• Infrastructure APIs: To restart services, scale resources, or modify configurations.
• Knowledge Bases: To retrieve historical documentation or runbooks.
• Communication Platforms: To update Slack channels or create ServiceNow tickets.

The Grounding Requirement

A critical challenge in applying generative AI to IT operations is “hallucination.” To ensure the agent makes decisions based on facts rather than probability, the methodology emphasizes “grounding” via Retrieval-Augmented Generation (RAG). The system feeds the LLM real-time telemetry from LogicMonitor alongside enterprise-specific runbooks. This ensures that the agent’s reasoning is constrained by the actual state of the infrastructure and the organization’s approved operating procedures.

Implementation: The Agentic Maturity Model

Adopting agentic AIOps is not an “all-or-nothing” proposition; it follows a maturity curve that balances autonomy with risk management.

1. Assisted Mode: The agent acts as a co-pilot, summarizing incidents and suggesting remediation steps to a human operator for approval.
2. Supervised Autonomy: The agent executes low-risk tasks autonomously (e.g., clearing disk space) while requiring permission for higher-impact changes (e.g., rebooting a production database).
3. Full Autonomy: The system operates independently within strictly defined guardrails, only involving humans for unprecedented or catastrophic failures.

This tiered approach allows organizations to build trust in the agent’s decision-making while gradually reducing the cognitive load on Site Reliability Engineering (SRE) teams.

Consequences for Enterprise IT and the Workforce

The shift toward agentic operations necessitates a change in the mindset of IT leadership. The focus moves from “managing tasks” to “managing outcomes.” The role of the human operator evolves from a manual troubleshooter to a “curator of intent.” Engineers will spend less time reacting to pagers and more time defining the policies, objectives, and constraints within which the agents must operate.

Furthermore, the integration of LogicMonitor with platforms like Worldwide Technologies (WWT) and NTT highlights a growing ecosystem of partnerships designed to provide the testing grounds (labs and POVs) necessary for enterprises to validate these autonomous workflows. The ultimate consequence is a significant reduction in noise—where thousands of alerts are distilled into a handful of actionable, or even self-resolving, insights.

Conclusion

Agentic AIOps marks the beginning of the autonomous enterprise. By combining the deep visibility of infrastructure monitoring with the sophisticated reasoning of generative AI, organizations can finally address the scale and speed requirements of modern digital services. While the technology is revolutionary, its success remains rooted in the fundamentals: high-quality data, clear governance, and a phased approach to building autonomous trust.

Links:

• AWS re:Invent 2025 – Agentic AIOps: How LogicMonitor Prepares Enterprises for AI-Driven IT (AIM232)
• LogicMonitor Official Website
• Deloitte Consulting – Emerging Technology Research
• Worldwide Technology (WWT) – LogicMonitor Partnership

Lecturers

Resh Desai, Zach Miller, and Jake Farrell presented this session. Resh Desai works as a solutions architect at Amazon Web Services, driving forward developments in secrets management. Zach Miller is a Senior Worldwide Security Specialist Solutions Architect at AWS, specializing in cryptography, keys, secrets, and certificates. Jake Farrell serves as Senior Director of Engineering at Acquia, which provides open digital experience platforms.

Abstract

The presentation sheds light on the evolution of secrets management, highlighting AWS Secrets Manager as a central tool for handling the complete lifecycle of sensitive credentials. It weighs the advantages and drawbacks of centralized versus decentralized approaches, outlines key capabilities like encryption, automated rotation, cross-region replication, and high-volume retrieval, and details Acquia’s comprehensive migration efforts. In addition, it explores strategies for multi-tenant separation, patterns for Kubernetes integration, future synergies with agentic AI, and the latest service improvements that support third-party rotations and easier container-based deployments.

Core Functionalities of AWS Secrets Manager

AWS Secrets Manager provides a purpose-built service dedicated to managing the entire lifecycle of application secrets, database credentials, and API keys, setting it apart from IAM for identity management or KMS for cryptographic operations. By design, every secret undergoes envelope encryption with AWS-managed KMS keys, though users can opt for customer-managed keys to support scenarios such as cross-account sharing.

This setup integrates smoothly with CloudTrail to deliver thorough auditing of all actions, from creation and modification to deletion. Automation through Lambda enables rotation schedules that align precisely with enterprise policies, whether set at 30 or 90 days. For resilience, multi-region replication ensures secrets remain available during regional failovers. The service handles up to 10,000 transactions per second for retrieval, further enhanced by an open-source agent that implements caching with configurable time-to-live periods, thereby improving both efficiency and the overall developer experience.

Together, these features create a secure and traceable environment that integrates seamlessly with the wider AWS security landscape.

Navigating Centralized and Decentralized Deployment Choices

When designing secrets storage, architects must decide between consolidating secrets in a single dedicated account or distributing them closer to the applications that consume them. Centralized configurations often resonate with organizations in regulated sectors, as they allow for standardized practices in naming, tagging, and permission enforcement—typically achieved through enforced CI/CD pipelines or bespoke abstraction layers. Such consistency bolsters monitoring and control across the enterprise, although it requires significant initial investment in development and can introduce latency when adopting newly released capabilities.

On the other hand, a decentralized model empowers individual application teams to manage secrets directly via consoles or SDKs, offering greater adaptability to unique requirements. This approach streamlines onboarding and accommodates specialized needs more naturally, but it calls for robust supplementary governance to ensure alignment with broader standards.

In practice, the ideal configuration depends on factors like secret creation processes, ongoing management, replication demands, access patterns, and visibility needs, reflecting insights gathered from diverse customer experiences rather than a one-size-fits-all rule.

Acquia’s Migration Experience and Multi-Tenant Architecture

Acquia maintains oversight of over 300,000 distinct secret paths distributed across multiple AWS accounts, supporting millions of daily ephemeral pod instances and tens of thousands of hourly API interactions. Moving away from older systems required careful categorization of secrets into groups such as customer-supplied elements (including third-party tokens and environment variables), internal service communications, and emerging hybrid forms suited to AI agents.

To manage this complexity, Acquia developed a custom fronting API that applies type-specific rules for validation, scoping, and lifecycle policies, such as mandatory rotation or timed expiry. Rigorous least-privilege principles ensure complete separation between platform operations and customer data. For delivery into runtime environments, the organization relies on open-source components like the External Secrets Operator combined with AWS CSI drivers, which synchronize and inject secrets into Kubernetes as variables, configuration templates, or command-line flags. Strategic caching layers further reduce direct API calls, delivering noticeable gains in speed and expense control.

Through this disciplined, layered framework, Acquia achieves robust multi-tenancy while addressing gaps that IAM alone cannot fully cover in interconnected service scenarios.

Future Directions in Agentic AI Collaboration

Looking ahead, Acquia’s designs feature an AI gateway that provides a unified point for observing model invocations routed through Amazon Bedrock, complemented by a standardized factory for quickly provisioning secure agents. By embedding Secrets Manager deeply, the platform enables on-demand injection of properly scoped credentials, allowing smooth evolution alongside emerging AI features without compromising protective measures.

This ongoing partnership with AWS has yielded tangible benefits in operational streamlining, lower maintenance burdens, and enhanced overall performance.

Latest Service Developments and Their Wider Impact

Innovations continue to simplify adoption in container environments, with EKS add-ons now automating the installation and configuration of CSI drivers. The introduction of managed external secrets brings one-click rotation capabilities to external providers like Salesforce, removing the need for custom scripting and eliminating risks of desynchronization.

Native integrations now span more than 55 AWS services, making secret management largely invisible to end users. These progresses reduce entry barriers to advanced security practices, enabling teams to concentrate on innovation even as autonomous systems increase demands on privilege management.

In essence, effective secrets governance forms the bedrock of durable, expandable systems vital for both current operations and forthcoming intelligent workloads.

Links:

• Lecture Video
• Jake Farrell on LinkedIn
• Acquia Official Website

Lecturer

Alexander Chatzizacharias is a software engineer at JDriven, a specialized consultancy in the Netherlands focused on JVM technologies and modern software development practices. With a unique background blending Dutch and Greek influences and a keen interest in game studies, Alexander brings creativity and playful thinking to technical challenges. He frequently speaks on topics including Java, Spring Boot, AI applications, and innovative development workflows.

Abstract

As mainstream AI coding assistants converge toward similar polished but somewhat generic experiences, Alexander Chatzizacharias demonstrates how to build a highly personalized, characterful AI pair programmer named “Pip.” Inspired by interactions with a sarcastic colleague named Ricardo, Pip incorporates personality through vectorized Slack history, utilizes Spring Boot and Kotlin, runs entirely locally with Qwen models via Ollama, and employs sophisticated workflows, multi-vector RAG, and the Model Context Protocol (MCP) to create delightful and productive assistance while addressing challenges like non-determinism and model drift.

The Homogenization of AI Assistants and the Quest for Personality

Alexander observes that leading AI coding tools have converged on remarkably similar chat-based interfaces and interaction patterns, largely influenced by OpenAI’s design choices. While incremental improvements continue, the overall experience feels increasingly uniform. This observation inspired the creation of Pip — an intentionally quirky, sarcastic AI pair programmer that injects personality drawn from real colleague interactions.

By processing Slack conversation history into vector embeddings stored in Qdrant, Pip can retrieve and emulate Ricardo’s characteristic sarcastic tone, witty retorts, and playful threats (such as threatening to delete poorly written code). This transforms the assistant from a neutral tool into a more engaging, human-like collaborator that questions unclear requirements, offers humorous feedback, and makes the development process more enjoyable.

Technical Architecture: Workflows, Agents, and Local Execution

Pip is implemented as a Spring Boot application written in Kotlin, with an IntelliJ IDEA plugin providing the frontend interface. Everything runs locally to maintain privacy and control: Qwen 3.5 models served through Ollama handle the language tasks.

Rather than pursuing fully autonomous agents, Alexander favors structured workflows that provide greater determinism and reliability — attributes particularly valued in enterprise environments. A categorization agent, functioning as an LLM-as-Judge, routes incoming queries to appropriate specialized handlers. Each handler uses carefully crafted system prompts derived from Slack history to consistently embody the desired personality traits.

The architecture incorporates multiple specialized agents for response generation, sophisticated RAG pipelines leveraging both dense and sparse vector representations with ColBERT reranking for improved retrieval quality, and integration with the Model Context Protocol (MCP) for tool usage such as playing music or generating memes when appropriate.

RAG, Tools, and the Challenges of Non-Determinism

Retrieval-Augmented Generation forms a cornerstone of Pip’s capabilities, dynamically pulling relevant context to overcome the inherent token limitations of even advanced models. Multi-vector search strategies combine semantic understanding with keyword precision for more reliable information retrieval from project documentation, codebases, and conversation history.

Tool integration via MCP enables rich interactions but introduces additional complexity due to the non-deterministic nature of local models. Alexander discusses practical challenges including prompt sensitivity to model updates (“model locking” strategies), the art of prompt engineering which he likens to “vibe checking,” and the necessity of implementing guardrails to maintain appropriate behavior boundaries.

Implications for Future AI Development

Alexander encourages attendees to experiment with building personalized, domain-specific AI assistants using accessible open-source tools. While acknowledging the increasing commercialization of AI, he emphasizes the current window of opportunity for creative, playful implementations that enhance both productivity and developer satisfaction.

Pip serves as an inspiring example of how thoughtful combination of RAG techniques, vector databases, workflow orchestration, and personality injection can create AI tools that feel genuinely collaborative rather than merely functional.

Links:

• Video: How to build your own fun and absurd pair programmer
• Alexander Chatzizacharias on X/Twitter
• JDriven
• Qdrant Vector Database
• Ollama

Lecturer

Mortaza Chowri is the Head of Product Management for the AWS Transform team, where he leads the development of next-generation tools for complex workload migration. He is an expert in leveraging generative AI to automate technical debt reduction for large-scale enterprises. Joining him are Alexi and Ravi, who serve as senior architects within the AWS Transform division, specializing in agentic AI implementation and the creation of composable system frameworks. The session also features strategic insights from the leadership team at Capgemini, who collaborate with AWS to deliver industry-specific modernization solutions for global banking and automotive clients.

Abstract

Enterprise modernization is frequently paralyzed by the extreme complexity of legacy systems, particularly decades-old mainframes and aging Windows-bound .NET applications. This article explores the innovative framework of AWS Transform, a centralized service that utilizes “Agentic AI” to automate and streamline the migration process. The methodology centers on the concept of composability, which allows AWS partners to integrate their proprietary industry knowledge and specialized tools with foundational AI agents. By utilizing a sophisticated chat-based interface and automated business rule extraction, the platform enables a seamless transition from legacy COBOL and .NET Framework 4.x to modern, cloud-native architectures. The analysis demonstrates how these composable agents create a continuous feedback loop that significantly reduces manual effort, improves documentation, and ensures business logic remains intact during high-risk migrations.

Context: The Burden of Technical Debt and Knowledge Atrophy

Many of the world’s most critical systems, particularly in finance and manufacturing, are still dependent on infrastructure built in the late 20th century. These legacy environments present three primary obstacles that prevent organizations from achieving modern agility. First, knowledge atrophy has become a critical risk, as the original architects of these mainframe systems have often retired, leaving behind “black box” applications that lack contemporary documentation. Second, the technical debt associated with older languages like COBOL is immense, as these systems were never designed to leverage modern cloud features such as serverless compute or elastic auto-scaling.

Third, the mission-critical nature of these systems creates a state of risk aversion, where the fear of breaking a core business process during a manual rewrite often leads to stagnation. AWS Transform was specifically developed to break this cycle of inertia. By providing a unified experience that integrates discovery, assessment, and modernization into a single platform, AWS allows enterprises to view their legacy code as an asset to be reimagined rather than a liability to be feared.

Methodology: Agentic AI and the Composable Framework

The core technical innovation of AWS Transform is the transition from static point solutions to a dynamic, “unified experience” powered by specialized AI agents. These agents are designed to perform complex technical tasks with a level of autonomy that far exceeds traditional automation scripts. The methodology is built upon several key pillars of agentic behavior. Discovery agents are tasked with automatically mapping technical artifacts, such as physical servers and complex database schemas, to their optimal cloud-native equivalents.

Modernization agents, specifically those tuned for mainframe environments, perform the difficult work of extracting business rules from legacy code. This process generates comprehensive documentation that allows current engineers to “comprehend” the underlying logic of systems they did not build. The most transformative aspect of this methodology is its composability for partners. AWS provides the foundational intelligence and large language models, while partners such as Capgemini can “compose” these with their own specialized knowledge bases and custom transformation rules. This enables the creation of industry-specific agents, such as a modernization assistant specifically optimized for banking regulations or complex automotive production logic.

Technical Analysis of Mainframe Rule Extraction

The implementation of these agents in real-world scenarios, particularly through the collaboration with Capgemini, highlights a sophisticated “forward engineering” approach. In this workflow, the AI agents first scan the legacy code to identify core business logic and immutable rules. This extraction phase is critical because it ensures that while the code is updated, the essential business functions remain perfectly intact. Following extraction, the reimagination phase begins, where these rules are integrated into a modern architecture that meets cloud-native standards for security and performance.

Practitioners interact with these systems through a chat experience within the AWS Transform interface, allowing them to query both the AI agents and integrated domain experts directly. This interaction model democratizes the modernization process, making it accessible to developers who may not have expertise in COBOL but are proficient in modern languages like Java or Python. The platform serves as a bridge, translating the “what” of legacy business logic into the “how” of modern cloud execution.

Outcomes: Efficiency, Consistency, and Continuous Learning

The deployment of composable AI agents has fundamentally altered the economics and speed of enterprise modernization. By automating the most labor-intensive parts of code comprehension and translation, organizations have reported a reduction in manual effort by as much as 80%. This allows teams to focus on high-value innovation rather than the repetitive task of line-by-line code migration. Furthermore, the platform ensures architectural consistency across a large organization, preventing the fragmentation that often occurs when different teams use varying migration tools.

One of the most significant consequences of this approach is the continuous improvement of the agents themselves. Every modernization task performed through the platform provides feedback data that enhances the underlying AI models. As these agents encounter more diverse enterprise environments, their ability to handle edge cases and complex business rules grows exponentially. This creates a virtuous cycle where each successful migration makes the next one faster and more reliable, effectively solving the problem of knowledge atrophy for the long term.

Conclusion

The shift toward agentic AI and composable architectures represents a milestone in the evolution of enterprise IT. AWS Transform provides a robust framework that allows organizations to tackle their most daunting legacy challenges with a level of confidence and speed that was previously impossible. By allowing partners to integrate their unique industry expertise into a centralized AI system, AWS has created a scalable ecosystem that transforms modernization from a risky, multi-year endeavor into a manageable and continuous strategic process.

Links:

• AWS Transform Service Overview
• Capgemini Mainframe Modernization
• AWS Partner Central
• Watch the Technical Deep Dive

Lecturer

Kevin Dubois is a Senior Principal Developer Advocate at IBM, previously with Red Hat, focusing on Java, AI, and cloud-native development. As a Java Champion and Technical Lead for the CNCF Developer Experience Technical Advisory Group, Kevin authors content, speaks internationally, and contributes to open-source projects. Mario Fusco, co-presenter, is a Senior Principal Software Engineer at IBM (Red Hat), leading the Drools project. A Java Champion with expertise in functional programming and domain-specific languages, Mario coordinates the Milano Java User Group and frequently speaks on software engineering topics. Relevant links include Kevin’s LinkedIn profile (https://ch.linkedin.com/in/kevindubois), Mario’s LinkedIn profile (https://it.linkedin.com/in/mario-fusco-3467213), and Mario’s X account (https://x.com/mariofusco).

Abstract

This article investigates patterns in agentic AI systems as presented by Kevin Dubois and Mario Fusco, emphasizing orchestration of AI services for complex tasks. It delineates foundational components, workflow-based orchestration, autonomous agent models, and extensible planners. Through analysis of methodologies in LangChain4j with Quarkus, it elucidates contexts, implementations, and ramifications for building sophisticated AI applications.

Foundations of AI Services and Agentic Systems

Kevin and Mario initiate their discourse by establishing core elements of AI-infused applications, particularly within Java ecosystems using LangChain4j and Quarkus. An AI service fundamentally interfaces with a large language model (LLM) to process inputs and yield responses. However, effective integration demands more: precise prompting to elicit desired outputs, memory management to sustain conversational context, tool invocation for external actions, and data augmentation via retrieval-augmented generation (RAG).

Prompting emerges as pivotal; vague instructions yield suboptimal results, whereas structured prompts enhance accuracy. Memory, absent in standalone LLMs, requires client-side tracking—LangChain4j automates this, customizable via caching. Tools enable LLMs to perform actions like database queries or email dispatch, via function calling where LLMs request tool usage.

RAG integrates proprietary data: embeddings store vectorized information in databases like Pinecone, retrieved to enrich prompts. Moderation filters harmful content, ensuring ethical outputs.

Agentic systems extend this: agents, autonomous entities with goals, leverage these components. Patterns categorize into workflows (predefined paths) and autonomous agents (dynamic LLM-directed processes). Contexts include scenarios needing multi-step reasoning, like trip planning involving weather, flights, and accommodations.

Implications: These foundations enable modular, scalable AI, but demand careful design to mitigate errors like hallucinations.

Code illustrates basics:

@RegisterAiService
interface WeatherAgent {
    String getWeather(String city);
}

This defines an AI service interfacing with an LLM for weather queries.

Workflow-Based Orchestration of Agents

Workflow patterns orchestrate agents through coded sequences, suitable for predictable tasks. Kevin and Mario detail sequential, parallel, conditional, and looping workflows in LangChain4j.

Sequential invokes agents in order: e.g., weather retrieval followed by outfit suggestion. Parallel executes concurrently, aggregating outputs—useful for independent subtasks like multi-city weather checks.

Conditional branches based on outputs: if weather is rainy, suggest indoor activities. Looping iterates until conditions met, like refining content via reviewer-critic cycles.

Methodology employs builders:

AgenticSystem system = AgenticSystem.builder()
    .sequence(weatherAgent, outfitAgent)
    .build();

Execution yields structured results, with event logs for monitoring.

Contexts: Workflows suit deterministic processes, reducing LLM variability. Implications: Enhance efficiency but limit adaptability; error handling via retries or prompt adjustments is crucial.

Autonomous and Dynamic Agent Orchestration

Autonomous patterns empower an LLM-orchestrator to dynamically select agents, ideal for unstructured tasks. The orchestrator evaluates inputs, plans invocations, and executes, adapting via reasoning.

Mario explains: Orchestrator prompts guide tool (agent) selection. Execution involves planning, tool calls, and result integration until resolution.

AgenticSystem system = AgenticSystem.builder()
    .autonomous(orchestrator)
    .agents(agent1, agent2)
    .build();

Contexts: Handles ambiguity, like open-ended queries. Implications: Increases flexibility but risks infinite loops or off-track reasoning; human-in-the-loop mitigates via approvals.

Multimodal extensions process PDFs or generate images, expanding applicability.

Extensible Planners for Custom Agentic Patterns

To accommodate diverse needs, Mario introduces pluggable planners, abstracting orchestration. This service provider interface (SPI) allows custom implementations, like goal-oriented patterns using A* search.

Planners initialize with agents, determining next actions: invoke agents (sequentially/parallel) or conclude. Existing patterns refactor atop this.

Goal-oriented example: Define prerequisites and goals; algorithm generates invocation graphs.

Planner customPlanner = new GoalOrientedPlanner(agents);
AgenticSystem system = AgenticSystem.builder()
    .planner(() -> customPlanner)
    .build();

Hybridization combines patterns, e.g., goal-oriented with loops for refinement.

Contexts: Custom scenarios like adaptive learning systems. Implications: Fosters innovation, but requires algorithmic expertise; promotes modularity in AI design.

In summary, Kevin and Mario’s patterns advance agentic AI, blending structure with dynamism for robust applications.

Links:

• Lecture Video
• Kevin Dubois on LinkedIn
• Mario Fusco on LinkedIn
• Mario Fusco on X

Lecturer

Danny Leybovich is a Product Lead at Anthropic, dedicated to building the infrastructure and models that empower the next generation of AI developers. With a focus on high-reasoning models and developer experience, Danny has been instrumental in the launch of Claude Code and the evolution of Anthropic’s agentic framework. His work centers on the practical realities of moving AI from “cool demo” to “reliable autonomous system.”

Abstract

2025 marked a pivotal shift in the artificial intelligence landscape: the transition from interactive chatbots to autonomous AI agents. This article synthesizes the key discoveries made by Anthropic during this transformative year, particularly through the development of Claude Code and the deployment of the Opus 4.5 frontier model. It explores the “agentic architecture” required for long-horizon autonomous work, emphasizing the critical roles of context engineering and skill acquisition. The analysis examines the shift toward “agent-first” workflows, where the model is no longer a passive assistant but an active participant with multi-hour reasoning capabilities. By investigating patterns of reliability and the evolution of AI engineering practices, this article provides a roadmap for the next wave of agentic AI.

The Shift to Agent-First Workflows

In the early stages of generative AI, the predominant interaction pattern was the “chat” interface—a stateless exchange where a human provided a prompt and the model provided a response. 2025 saw the obsolescence of this limited model in favor of “agent-first” workflows. In an agentic architecture, the model is granted the autonomy to use tools, manage its own memory, and pursue goals over extended periods—sometimes lasting hours.

This shift changes the fundamental role of the developer. Instead of engineering a single prompt, the developer now engineers an environment in which an agent can succeed. This involves defining clear objectives, providing access to necessary APIs, and implementing “guardrails” that ensure the agent remains on track during autonomous loops. The rise of “Claude Code”—an agent that can autonomously file GitHub issues and build applications—serves as the flagship example of this transition.

Advanced Context Engineering: Beyond the Context Window

While early AI discussions focused heavily on the size of the “context window,” Anthropic’s experience in 2025 highlighted that quality of context is far more important than raw volume. Context engineering is the practice of strategically selecting and formatting the information provided to the model to maximize reasoning accuracy and minimize hallucinations.

Effective context engineering for agents involves:

1. State Management: Keeping track of what the agent has already done and what remains to be accomplished.
2. Relevant Document Retrieval: Using RAG (Retrieval-Augmented Generation) to pull only the most pertinent information into the reasoning loop.
3. Semantic Chunking: Ensuring that the information is presented in a way that the model can easily digest and connect to other data points.

By focusing on context engineering, developers can enable agents to maintain “state” across long horizons, allowing for complex tasks like refactoring an entire codebase or conducting multi-step regulatory research without losing the thread of the original objective.

Tool Construction and Skill Acquisition

A primary differentiator for AI agents is their ability to interact with the world through tools. In 2025, Anthropic refined the methodology for “teaching” agents new skills through tool construction. A “skill” is essentially a well-defined tool—such as a Python interpreter, a SQL query engine, or a web search function—that the model knows how and when to invoke.

The engineering challenge lies in creating “reliable” tools. If a tool’s output is ambiguous or inconsistent, the agent’s reasoning loop will break. Therefore, tool writing has become a core discipline within AI engineering. Developers must create tools that provide “structured feedback” to the model, allowing the agent to self-correct if a tool call fails. This iterative loop of tool use and self-correction is what allows agents to handle “long-horizon” tasks that were previously impossible for LLMs.

Analyzing the Performance of Opus 4.5

The release of the Opus 4.5 frontier model provided the reasoning “horsepower” necessary for the agentic revolution. Unlike smaller models that might prioritize speed, Opus 4.5 is optimized for high-reasoning tasks. Its performance characteristics include a significant reduction in “logic drift”—the tendency of a model to lose focus during long sequences of thought.

In production environments, Opus 4.5 has demonstrated an ability to navigate “deep” decision trees. For example, when tasked with finding a bug in a complex software system, the model can formulate a hypothesis, write a test to prove it, analyze the test results, and then iteratively refine its approach. This capability for “autonomous debugging” is a hallmark of the newest wave of AI, where the model’s intelligence is leveraged not just for text generation, but for problem-solving in dynamic environments.

Code Sample: Defining a Secure Tool for Claude Agentic Workflows

'''
 Conceptual tool definition for an Anthropic Agent
 This tool allows the agent to safely query a database
''' 

def get_tool_definition():
    return {
        "name": "query_database",
        "description": "Allows the agent to execute read-only SQL queries to retrieve customer data.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The SQL query to execute. Must be read-only."
                },
                "max_rows": {
                    "type": "integer",
                    "default": 10
                }
            },
            "required": ["query"]
        }
    }

'''
This structure enables the model to 'reason' about when it needs 
to fetch data versus when it can rely on its internal knowledge.
'''

Long-Horizon Autonomous Reliability

The final frontier explored in 2025 was the challenge of reliability. For an agent to be truly useful, it must be able to work for hours without human intervention. This requires a robust infrastructure that can handle model timeouts, API failures, and unexpected edge cases.

Anthropic’s research into long-horizon agents suggests that reliability is not a feature of the model alone, but a result of the model-infrastructure synergy. This includes:

• Checkpointing: Periodically saving the agent’s state so it can resume after a failure.
• Human-in-the-Loop (HITL) Triggers: Designing the agent to “ask for help” when it reaches a confidence threshold that is too low.
• Verification Loops: Implementing a secondary model or a deterministic process to verify the agent’s output before it is committed.

These patterns are what define the current state of the art in AI engineering, moving the industry toward a future where agents are trusted partners in the enterprise.

Conclusion

The lessons of 2025 are clear: the future of AI belongs to autonomous agents. By mastering the disciplines of context engineering, tool construction, and long-horizon reliability, developers can leverage models like Claude Opus 4.5 to solve problems of unprecedented complexity. As we look ahead, the trends established this year—particularly the move toward agent-first workflows—will define the next decade of technological innovation. The demo era is over; the production era of agentic AI has begun.

Links:

• Anthropic Official Website
• Claude Model Documentation
• Anthropic on AWS Bedrock