Introducing agents

We stand at a pivotal inflection point in the history of computing. The transition from traditional software systems to autonomous agents represents a fundamental paradigm shift that transforms how digital systems operate and interact with their environments. While conventional programs operate within predetermined pathways defined by explicit instructions, agent-based systems exhibit goal-directed behavior, maintain persistent state, and adapt their strategies based on environmental feedback. This transformation challenges established software engineering principles and introduces new frameworks for conceptualizing intelligence in computational systems.

The distinction between traditional software and agent-based approaches is not merely semantic but architectural. While conventional systems process discrete inputs to generate predictable outputs, agents operate continuously within dynamic environments, forming internal representations, making decisions under uncertainty, and learning from experience. For practitioners trained in deterministic programming models, this shift requires not only new technical skills but a reconceptualization of how intelligent systems function and evolve.

Key traits that distinguish intelligent agents from traditional software include:

• Autonomy: The ability to operate without continuous human guidance
• Persistence: Maintaining state and memory across interactions
• Reactivity: Responding to changes in the environment in real time
• Proactiveness: Initiating actions based on internal goals, not just external triggers
• Adaptability: Learning from experience and modifying behavior accordingly
• Goal-orientation: Pursuing objectives through planning and reasoning under uncertainty

In common usage, an agent is one that acts or exerts power (Merriam-Webster). Within AI, this definition evolves into a more technical construct: an AI agent is a computational system that perceives its environment, processes internal state, and takes actions to achieve defined goals. These systems exhibit autonomy, adaptability, and reactivity, key attributes that differentiate them from traditional software programs.

An agent operates not merely by reacting to inputs, but by maintaining context, managing goals, and adjusting strategies based on feedback. This dynamic behavior draws from the paradigm of situated AI, where intelligence emerges from continuous interaction with the environment. Franklin and Graesser (1997) encapsulated this concept:

An autonomous agent is a system situated within and a part of an environment that senses that environment and acts on it, over time, in pursuit of its own agenda.

This definition laid the groundwork for architectures that incorporate sensing, planning, acting, and learning. In enterprise applications, agents are increasingly deployed as digital workers (handling customer onboarding, processing invoices, managing workflows) each with persistent state, memory, and feedback mechanisms.

The history of AI agent development can be segmented into distinct technological eras:

• 1970s–1980s: Rule-based expert systems, such as MYCIN (a Stanford-developed system for diagnosing blood infections and recommending antibiotics), used logic-based inference engines to solve narrowly defined problems. Despite deterministic precision, these systems were brittle and inflexible.
• 1990s: Classical machine learning methods like decision trees and SVMs introduced pattern recognition capabilities. While more adaptive than rule systems, they remained task-specific and stateless.
• 2010s: Deep learning revolutionized data perception. Speech recognition, image analysis, and translation reached human-level performance. However, these models were largely reactive, designed for input-output prediction rather than autonomous behavior.
• 2020s and beyond: The advent of large language models (LLMs), that is, AI systems trained on vast text datasets to understand and generate human language, and transformers, neural network architectures that excel at processing sequential data, introduced emergent reasoning, natural language generation, and few-shot learning. Yet early LLMs were limited by context size, lack of memory, and tool integration.

While many recent advances in AI, such as retrieval-augmented generation (RAG), external tool use, API orchestration, and memory systems, have been pivotal in their own right, they also serve as critical enablers for building more capable autonomous agents. Frameworks such as LangGraph, CrewAI, and AutoGen support planning, decision-making, and real-time interaction, enabling agents to complete multi-step goals in open-ended environments.

For instance, in customer support, the progression has been dramatic:

• 2010: Static FAQ scripts provided predetermined responses to common questions, requiring human intervention for any deviation
• 2018: ML-based ticket routing systems could categorize and assign support requests to appropriate departments but still required human resolution
• 2025: Advanced multi-agent systems now demonstrate resolution rates of 70-85% in production deployments (based on implementations at companies like Zendesk, Intercom, and ServiceNow), integrating LLMs for natural conversation, account systems for personalized context, and live knowledge bases for current information

This evolutionary trajectory, illustrated in Figure 1.1, highlights fundamental architectural and philosophical distinctions between conventional AI applications and truly autonomous agent systems; these are differences that extend well beyond technical implementation to how these systems operate, learn, and interact with their environments. These architectural shifts are not just academic; they translate into measurable business outcomes such as reduced support costs, increased first-contact resolution rates, faster onboarding, and greater scalability across customer touchpoints.

Figure 1.1 – Evolution of AI agent technologies

Having traced the historical evolution of AI agents from rule-based systems to today's sophisticated autonomous entities, we now turn to examine the structural foundations that enable this intelligent behavior. Understanding how agents are architected—the cognitive loops, communication patterns, and design choices that transform computational systems into goal-directed entities—is essential for building effective agent-based solutions.