We are witnessing a profound technological transformation driven by autonomous agents—intelligent software systems capable of independent reasoning, decision making, and interacting effectively within dynamic environments. Unlike traditional software, autonomous agents interpret contexts, adapt to changing scenarios, and perform sophisticated actions with minimal human oversight.
That’s great, but it’s difficult to trust a black box that can deceive users. Let’s see what the book has to offer, one concern I have going into it is that the field of AI evolves so rapidly that this might be irrelevant soon.
Agents can fall into different categories:
- Business-task agents: utilize business workflows and integrations
- Conversational agents: chatbots and customer services
- Research agents: information gathering and synthesis
- Analytics agents: interpreting dataset and generating insights
- Developer agents: coding agents
- Domain-specific agents: for professional domains such as legal, medical, etc.
- Browser-using agents: agents that can interact with the web
Agents allow us to focus on strategic oversight, review and high-level decision making.
The principles behind building effective agentic systems is to consider:
- Scalability: ensure agents can scale to handle growing workloads and diverse tasks by utilizing distributed cloud-based infrastructure.
- Modularity: design agents with independent and interchangeable components.
- Continuous learning: equip agents with mechanisms to learn from experience, allowing them to learn from user feedback to refine behaviour.
- Resilience: handle errors and unexpected conditions gracefully.
- Future-proofing: using open standards to foster a culture of innovation and adapting quickly to emerging technologies and user behaviours.
The core components of any agent system are the model itself, the tools, memory and planning capabilities.
While large foundational models are well suited for open-ended environments–where creativity is essential–these models can be expensive and slow. In contrast, smaller models such as ModernBERT or Phi-4 are more appropriate for agents performing well-defined, repetitive tasks. These smaller models respond quickly, are cheaper to deploy and maintain, and can even run on local hardware.
Tools are tailored for the tasks the agent is required to solve and could fall into the categories of local tools, API-based tools, or Model Context Protocol (MCP) based tools.
MCP is a standardised schema for passing external knowledge, memory, and state into the model’s prompt. The protocol enables agents to inject rich, dynamic content directly into the model’s reasoning process without invoking separate tools.
Memory is the essential component that enables agents to store and retrieve information that is relevant to the current conversation, providing better context for agents to utilize and make coherent decisions with.
Long-term memory enables agents to store knowledge and experience in order to inform future actions, which could be useful for improving over time or providing personalized experiences.
When we talk about Orchestration, it is the logic that schedules and supervises a series of skills and dynamically creates a workflow that works towards a clear objective. The core of orchestration is evaluating a set of tools or skills and their likely outcomes, and deciding which path will most likely succeed. The world is a dynamic, chaotic place so good orchestrators should be able to monitor progress and change course when things go wrong.
Multi-agent architectures are when multiple agents work together to achieve a common goal, they are often used in complex environments where different aspects of a task need to be managed by specialized agents, or where parallel processing can improve efficiency and scalability.
Multi-agent systems allow:
- Collaboration and specialization
- Parallelism
- Improved scalability
- Redundancy and resilience
Robust testing is required to ensure agents can handle correctness, or the ability to deliver accurate results and expected outputs. Boundary testing evaluates how well the agent handles edge cases or strange inputs. Task-specific metrics are an evaluation technique used to ensure domain specific tasks like legal analysis meet the required domain’s accuracy and compliance requirements.
To evaluate models you should consider:
- User satisfaction scores: metrics to gauge how users feel about their interaction with the agent.
- Task completion rates: measure how often the agent successfully completes the user’s task.
- Explicit signals: provide opportunities for the user to provide feedback, such as thumbs-up or thumbs-down buttons, and the ability to accept or reject the generated results.
- Implicit signals: use interaction logs to gain insights into common points of failure such as misinterpretations or inappropriate responses.
When designing user interfaces, a key limitation is discoverability. Users often do not know what capabilities the agent supports or how to phrase commands effectively. This lack of affordance can lead to confusion and user frustration when the requests fall outside the agent’s supported scope. In addition, agents should communicate with short and unambiguous responses, and provide graceful failure and fallback mechanisms, or offer alternative suggestions when they cannot fulfill a request.
One of the most critical aspects of designing interfaces for agents is ensuring users can understand what the agent is capable of and how to interact with it effectively. In text interfaces, the absence of visible affordances leaves the user guessing what the agent can and cannot do. You can address this with action buttons below the input field, such as “track order” or “generate summary” which help guide users towards supported workflows. On-boarding tutorials and walkthroughs can also introduce users to the core functionality and help them gain confidence.
A useful pattern of UI is creating capability cards that list available functions in a structured way.
Suggestions can also be generated dynamically, so if a user starts typing a request you can autofill possible and supported workflow suggestions in the input placeholder.
Additionally, the agents should also be able to communicate their capabilities clearly in the conversation. This might include sending the first message, or providing a welcome message prompting the user with proactive questions.
While all of this is helpful, it’s important not to overwhelm the user with too many options at once.
The design of the conversation itself is important, for instance agents should not try to appear overly confident when something is uncertain – this can lead to a loss of trust.
Effective agents must know when to ask clarifying questions or seek user guidance. For instance if a user asks to book a ticket, the agent should ask if they would like a one-way or round-trip ticket. It can be helpful for the agent to use every opportunity to refine its understanding, rather than generating incorrect assumptions.
- Agents should be transparent about why they are asking questions
- Agents should avoid asking too many questions at once
- The conversation should not feel like an interrogation
- The most critical ambiguities should be addressed first
- When agents confidently ask for guidance, they transform uncertainty into productive collaboration
- When agents fail they should try to minimize user frustration, preserve trust and provide a clear path forwards
- When agents fail badly, the request could be escalated to a human
As the AI ecosystem matures, new standards are being introduced. The most notable so far is MCP which is like a “USB-C port for AI” and acts as a single, well defined interface that any data source or tool can expose, and any agent can consume, without specialized glue code.
MCP Server: the web server that exposes data via standardized JSON-RPC 2.0. The server can wrap anything from cloud storage, SQL databases or proprietary business logic.
MCP Client: any agent or LLM application that can speak in MCP. The client sends JSON requests and receives structured JSON from the server.
MCP provides a large number of benefits but several issues still need to be addressed such as authentication, access control and any potential attack vectors when multi-agent systems share the same endpoints.
The important take-away from tool use is to log everything, because when the system fails or does something unexpected then you can use the logs for observability, debugging and continuous improvement.
Orchestration is the core logic that handles user queries and coordinates calls to the foundational models. The orchestration layer can work with various types of agents, such as:
- Reflex agents: direct mapping from input to action without internal reasoning (e.g. if X, call tool Y)
- ReAct agents: works in an iterative loop: the model generates thought, selects and invokes a tool, observes the result and repeats as needed.
- Planner-Executor agents: splits work into planning with lots of subtasks, and execution as a separate step.
- Query-Decomposition agents: breaks complex questions into subquestions and invokes search or tools to synthesize a final answer
- Reflection agents: extends ReAct with interleaving thoughts, action and review to correct mistakes
- Deep Research agents: combine multiple agents for complex investigations which require extensive knowledge gathering, hypothesis testing and synthesis.
A core component of successful orchestration is context engineering, which ensures each agent has the right information and instructions to perform tasks effectively. This involves deciding what information to include, how to structure it for maximum clarity and relevance, and how to minimize token usage.
When it comes to memory, there are two kinds:
- Knowledge: factual or domain-specific content such as policy documents, customer or system logs, technical specs which are often retrieved via RAG.
- Memory: captures the agent’s own history such as prior user exchanges, tool outputs, and state updates.
To use memory effectively you need to manage the context window, where 1000 tokens ~ 750 words.
If you have memory, you can store past experiences and use them for future reference when a similar situation or problem appears. You can think of them as storing “case” files in an investigation.
When working on multi-agent systems, agents can collaborate to achieve shared goals and work in parallel, but at the cost of increased complexity and an additional communication overhead. When considering adding more agents to your system, these principles should be considered:
- Task decomposition: the importance of breaking tasks into smaller, manageable subtasks.
- Specialization: assign distinct roles for greater precision and effectiveness.
- Parsimony: use only the minimal number of agents necessary to achieve the desired functionality.
- Coordination: robust communication protocols help maintain alignment and reduce risks of conflict.
- Robustness: essential for fault tolerance and resilience.
- Efficiency: each agent adds to the complexity and communication overhead, so carefully balance the trade-offs of additional agents.
Communication between agents could form different structures such as have a manager coordinator, using a hierarchical system, a democratic voting system, an actor-critic relationship for quality control, etc.
The technical implementation of the communication between agents could be a message broker and queueing system, an event bus. To manage shared state a database could be used, vector storage, or object storage such as S3.
The next part of the book deals with monitoring and measuring performance, which, along with allowing teams to validate and optimise the performance of the systems, helps build trust and align with user expectations.
In agentic systems, measurement refers to the ability to identify clear and actionable metrics that align with the goals and requirements of the system, and then using those benchmarks to evaluate the agent’s ability to perform tasks and meet users’ expectations. By creating scenarios of high-priority use cases and measuring the agent’s success against these goals, it becomes possible to know and understand the agent’s limits and abilities, and also get a realistic understanding of how the agent behaves in unusual or unexpected terrain.
High quality evaluation sets can act as a living specification for the agent’s abilities. A solid testing suite of the agent’s abilities provides confidence that when the foundational models change over time, the agent is able to continue performing the tasks it was designed to do.
Monitoring agents isn’t simply about detecting problems, it’s the backbone of a feedback loop or memory system where agents are able to learn from past mistakes. It provides a foundation in which to reveal emergent issues and strange behaviours.
While protecting agentic systems and cybersecurity is a complicated section of the book, it does say accountability is important to create clear lines of responsibility for the agent’s actions, decisions and consequences… without clear lines it is easy for issues to go unaddressed which can lead to eroding trust with users and stakeholders.
Some methods of accountability could rely on decision logs, user interaction logs or error and failure logs which can serve as record keeping mechanisms. After traceability is in place, escalation mechanisms must be introduced to provide human oversight.
My optimism in the beginning of this book was quite high, and it painted a great picture of how agentic systems can transform the way we interact with software… but the ending was a clear reminder that these are black-box systems with probabilistic output that can’t be trusted. It really is a strange and unusual situation we find ourselves in with agents, in that they can provide huge benefits and huge risks at the same time.