Blogs

Why Do We Need Agents? 

The notion of “agents” or “agentic AI” is a recent development in artificial intelligence that significantly enhances the power and robustness of Large Language Models (LLMs) applications.

To understand why the need for Agents arose, we first need to understand the differences between traditional programming and AI-driven programming. This comparison will highlight the shortcomings of current AI processes and explain how agents are designed to address these issues.

Traditional Software Development

Traditional software development, which was the norm before the recent rise of generative AI, relies on humans providing explicit instructions to computers to dictate how tasks should be executed. These instructions are rigid, following a predefined sequence of steps, often referred to as algorithms. The flow of a traditional program can be structured as follows:

For instance, starting from point A, depending on various input values, the algorithm may move to point B, C, or D, as shown in the diagram. The algorithm follows a fixed set of paths, resulting in predictable and well-defined outcomes.

AI-Driven Software Development

AI-driven software development involves usage of generative AI models to perform tasks. Unlike traditional methods, these systems do not rely on explicit instructions or a fixed sequence of steps for every scenario. Instead, they operate based on a description of the task and leverage past data and patterns to transform inputs, make decisions, and generate predictions. An example of flow of an AI application is illustrated below:

As the diagram shows, AI-driven systems have no fixed paths. Within a certain boundary, they can produce any output from the possible options, such as A, B, C, or D.

Differences Between Traditional & AI-Driven Software Development

AI-driven software development differs from traditional software development primarily in that its aspects — inputs, transformations, and outputs — are fuzzy, meaning flexible and not well-defined. While traditional programming is deterministic, with predictable results, AI-driven approaches yield probabilistic results, allowing for variability and adaptation.

In traditional programming, inputs and outputs are precisely defined by their quantity, size, and data types (e.g., text, integer, float). In contrast, AI-based software can handle input in various formats such as plain text, markdown, and tabular data, and produce outputs in varying formats such as bullet-point lists, JSON, and markdown.

Similarly, transformations in traditional programs typically involve mathematical computations, string operations, conditional logic, and iterative processes. AI software, however, performs transformations such as keywords extraction, ideas generation, and summarisation.

Fuzzy inputs, transformations, outputs

	Traditional Software Development	AI Software Development
Inputs	– text (string) with defined set (“happy”, “calm”) – Numerics (int ,float)	Fuzzy inputs: Open-ended text – Tabular data – Markdown – Text – Math operation
Transformations	– Maths calculations (+ – ➗ x) – f“Hello {first_name}, how are you?” – if, elif, else – for/while loops	Fuzzy transformations: – Extract list of key words – Rewrite as a paragraph – Answer a question – Brainstorm new ideas – Perform logic/maths reasoning
Outputs	– text (string) with defined set (“Positive”, “Neutral”) – Numerics (int ,float)	Fuzzy outputs: text – Paragraphs – Number(s) – JSON – Markdown
Notes	– Can be replicated	– Probabilistic: can be different every time

Limitations Of Traditional Programming

Traditional programming faces some challenges that makes it less suitable for every scenario such as:

• Need for Definitive Steps: Requires detailed and explicit instructions for every scenario.
• Limited Adaptability: Struggles with varying types of inputs and scenarios.
• Deep Problem Understanding: Necessitates a thorough understanding of the problem to define appropriate steps.

These problems call for a more flexible approach, which AI-driven software development provides, by not requiring explicit step-by-step definitions.Instead, AI software leverages patterns and data to adapt and perform tasks more flexibly and efficiently.

Limitations of AI Softwares

AI based software themselves are not without limitations. They often produce results that may not meet expectations or be in the desired format. Issues often arise with ambiguous inputs or contexts that differ from what the model was trained on.

While the probabilistic nature of AI allows for flexibility and adaptation — enabling a single LLM model to perform a range of tasks such as content summarisation, code writing, brainstorming, and teaching — this same variability can lead to unpredictable results.

To obtain the desired output from AI software like ChatGPT, iterative prompting is often required. For instance, if you ask the AI to “write briefly about the history of United States,” it may initially provide a detailed essay. You might then prompt it to summarise the information into bullet points, but the result could still be too lengthy for your liking. This iterative process continues until you achieve the desired result. This approach requires human intervention and presence, but ideally, we would want as little human involvement as possible in an AI-based system — here’s where agents come in.

Role Of AI Agents

To address the above challenges, AI agents are introduced. Simply put, AI agents replace the human in the iterative prompting cycle with an autonomous reasoning system. This system continuously works to refine the output until it meets the desired criteria. An AI agent takes an input, processes it through the LLM, evaluates the output, and if it’s not satisfactory, repeats the process until the output aligns with the requirements. This approach minimises the need for human intervention, making the AI-based system more efficient and effective.

Conclusion: The Need for AI Agents in Modern Systems

AI agents enhance traditional AI-based software by addressing issues such as unpredictability, unreliability, fuzziness, and the need for iterative adjustments, while also reducing human involvement. They offer the following key advantages:

• Predictability: Agents produce results that are more consistent and aligned with the desired outcomes.
• Reflection: Agents can evaluate and adjust their results as needed to improve performance.
• Collaboration: Agentic systems can involve multiple agents with distinct roles working together to achieve better results.

Now, we will delve into the practical aspects of designing and building agentic systems, breaking down their core components and properties for optimal performance.

What Are AI Agents? 

Components of Agentic Systems

As mentioned above, AI agents transform iterative human-AI interactions into autonomous systems. Several key components work together to form this autonomous system: Instruction, LLM, Reflection, Memory, and Tools.

Let’s take a look at these components one by one:

Instruction

Agents rely on instructions for their operation. These instructions serve as a blueprint, outlining the expected results and procedures, and helping the agent understand its tasks and goals.

LLM

This is the core reasoning engine. It processes information, generates responses, and performs the core tasks based on the instructions provided. It is essentially the “brain” of an agent.

Reflection

Reflection is mainly the part of agents that removes the need for iterative prompting by a human. When an LLM responds, the agent asks it to reflect on its response — identifying any issues or cases of not following instructions. It turns out this reflection process can significantly improve results even though it is the same LLM that is prompted repeatedly. Here’s an example of how a coding agent might utilise reflection given a task:

• Start by asking for the code for the task: “Please write code for {task}.”
• After receiving the resulting code, prompt the LLM to review the code for any issues: “Read the following code for {task}, review it for correctness, style, and efficiency, and indicate if there are any errors present: {<code>}.”
• Based on the feedback provided, ask the LLM to make the necessary changes: “Make the following changes in the given code. Changes: {<suggested changes>}. Code: {<code>}.”
• Repeat this process — review and revise — until no further changes are suggested.

Memory

Since agents involve multiple iterations of prompting and refining outputs, they require memory to track past results. There are 2 types of memory mainly used:

1. Short Term memory: Temporary storage that holds information relevant to the current task, allowing the agent (or multiple cooperating agents) to remember and learn from intermediate results.
2. Long Term Memory: Persistent storage that retains information from past executions. It can also include self-evaluations of past performance, enabling the agent to continuously improve over time.

Tools

Tools are what really empower AI agents. They significantly enhance the capabilities of agentic systems over simple LLMs by allowing these systems to interact with the external world and perform actions beyond their inherent capabilities. These tools, also referred to as skills, capabilities, or other terms in various frameworks and literature, can include APIs, code executors, data analysis tools, and internet searchers. For example:

• Weather API: Can be used by a travel planner agent to fetch current weather information for better planning decisions.
• Python Code Executor: Can be utilised for tasks involving data analysis or complex computations.
• Wolfram Alpha: Can be used for mathematical queries.

Properties That Make A Great Agent

To be effective, an AI agent should possess certain properties. These attributes should be kept in mind while designing agentic systems to ensure optimal performance.

Here are the seven key properties explained in detail:

1. Role Playing

Agents perform best when they have a clear and well-defined role. The more specific the role, the better the agent can understand and fulfil expectations. For instance, assigning an agent the role of a “FINRA (Financial Industry Regulatory Authority) approved financial analyst” is much more effective than a generic “data analyst”. To enhance the role, include a backstory or context along with the description.

2. Focus

Information overload can be detrimental to LLMs. Too much context or irrelevant details can lead to hallucinations, as the model might struggle to focus on the relevant information. It’s crucial to provide focused instructions, context, tools, and guardrails to keep the agent on track. It is also best to divide tasks into smaller subtasks and assign them to specialized agents, rather than relying on a single generalized agent with a broad role.

3. Tools

It is pertinent to provide an agent with the tools needed for its assigned task, but only the relevant ones. Supplying all available tools can lead to the agent using an unsuitable tool or one that is not important for the task, resulting in inefficiency and possibly hallucinations.

4. Cooperation

Being able to interact with other agents — such as passing on or delegating tasks, utilizing the expertise of others, or incorporating feedback —helps boost agents’ performances significantly. This approach, known as a Multi-Agent System, allows agents to operate autonomously without human interaction, as they exchange ideas and solve problems collaboratively.

A fascinating example of a multi-agent collaboration system is proposed in the paper titled “ChatDev: Communicative Agents for Software Development” (https://arxiv.org/abs/2307.07924). The paper introduces a completely autonomous software engineering system, as illustrated below, with agent teams for different phases of the software development lifecycle, such as ‘designing,’ ‘coding,’ and ‘testing.’ Additionally, an agent acts as a CEO to manage all teams and keep processes streamlined.

5. Guardrails

Guardrails are needed as AI systems can produce outputs with varying formats, accuracy, and sometimes even inappropriate content. They act as safety measures, ensuring the agent’s outputs meet specific quality standards and adhere to ethical guidelines. Guardrails can also prevent the agent from getting stuck in loops by limiting the number of iterations, controlling which tools it can use, and restricting the agents it can collaborate with.

6. Memory

A key aspect of intelligence is the ability to learn and improve, which depends on memory. By remembering past experiences — such as inputs, actions, and results — the agent can make better decisions in future tasks. This ongoing learning process is key to developing truly intelligent AI agents.

7. Planning

Planning involves breaking down processes into small steps. Encouraging LLMs to think through and plan before starting to answer or solve the problem at hand actually leads to better results. Here’s an example of how an agent may plan a task as explained in paper titled “HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face” (https://arxiv.org/abs/2303.17580 ):

Task: Given an image of a boy, generate an image of a girl in the same pose, reading a book, and create a voice snippet to describe the new image.

Plan:

• Pose Determination: Determine the boy’s pose in the initial image.
• Pose-to-image: Generate an image of a girl in the same pose, reading a book.
• Image-to-text: Describe the new image using text.
• Text-to-speech: Convert the text description to a voice snippet.

Creating effective AI agents requires careful consideration and implementation of the key properties discussed above. Interestingly, these qualities are also what you might look for in an ideal job candidate.

Now, we’ll dive into the practical implementation of AI agents using a framework called Crew AI.

Multi-Agent Systems With CrewAI 

So far, we have focused on the theoretical aspects of agents — why they’re needed, how they work, and what makes them effective. Now, we will shift our focus to practical implementation of agents using the CrewAI framework.

About CrewAI

CrewAI is one of the many frameworks available for implementing the concept of agents. It simplifies the process of building AI agents by providing features that focus on high-level concepts, allowing you to concentrate more on ideas and objectives rather than implementation details. The term ‘crew’ in CrewAI reflects the idea of a team working together to achieve a goal, emphasising that this framework supports and focuses on multi-agent systems.

CrewAI is a Python framework and can be installed via the following command:

pip install crewai

Core Concepts

CrewAI includes three building blocks for creating agentic systems: agents, tasks, and crews. These are explained below.

Agents

An agent is the smallest functional unit in CrewAI. It performs tasks, makes decisions, and communicates with other agents to achieve its objectives. Agents have attributes such as:

• Role: Specifies the agent’s function within the system. For example, in a software engineering agent-based system, roles may include ‘a UI designer,’ ‘a frontend developer,’ ‘a backend developer,’ ‘a tester,’ etc.
• Goal: Defines the agent’s ultimate purpose and the objective it aims to achieve, guiding its decision-making process. For example, for a “tester” agent in a software engineering system, the goal could be “to ensure the codebase is free of all types of bugs, including logical and syntactical ones, and that the code performs according to the requirements”.
• Backstory: Additional detailed information related to the role and goal that helps provide context and improve performance.

Tasks

Tasks are the specific jobs that agents handle within a multi-agent system. They detail what needs to be done, who’s doing it, and how it should be completed. Key attributes of tasks include:

• Description: The task’s purpose, objective, and what needs to be done. For instance, a task for a tester agent might be ‘write unit tests for the authentication module.
• Agent: Specifies the agent that is to perform the task.
• Expected Output: Describes how the end result of the task should appear and what is expected. For example, for the task of writing tests for the authentication module, the expected output might be “unit test functions for every function in the authentication module.”

Crews

Crews are a team of agents that work together to achieve a common goal by performing a set of tasks. They define how tasks are carried out, how agents collaborate, and the overall flow of the system. Their main attributes include:

• Tasks: The tasks that the agents in the crew are responsible for.
• Agents: The agents that are part of the crew.
• Process: The way tasks are carried out, the order in which they are performed, for example sequential or hierarchical.

There are various other attributes that may be assigned to agents, tasks, and crews, such as the LLM to use, tools to be utilised, and output formats, which can be explored in CrewAI’s documentation: https://docs.crewai.com/

The following diagram illustrates how a typical CrewAI looks. We define agents and assign tasks to them, then assemble them into a crew. We then “kickoff” the crew, initiating task execution and agent collaboration until the output is produced.

Implementing A Single Agent System

Let’s start by creating a single-agent system before progressing to a multi-agent one. For this example, we will develop a travel planning agentic system to create a travel itinerary based on user preferences such as destination, duration of the travel, budget, and interests. Let’s dive into the code.

Import necessary modules:

from crewai import Agent, Task, Crew

Define a function to create the agent, task, and crew, and to execute the agentic system:

def plan_travel_itinerary(destination, duration_days, budget_usd, interests):
   # Define the agent
   travel_planner_agent = Agent(
       role='Travel Itinerary Planner',
       goal='Create personalized travel itineraries',
       backstory="""As a travel itinerary planner, your role is to curate exciting and
       efficient travel plans for individuals or groups based on their preferences and interests.""",
   )
   # Define the task
   task = Task(
       description=f"""Create a travel itinerary for {duration_days} days in {destination} with a budget of ${budget_usd} USD.
       The itinerary should be tailored to the following interests: {interests}.""",
       expected_output='A briefly outlined but comprehensive travel itinerary only.',
       agent=travel_planner_agent,
   )
   # Create crew
   crew = Crew(
       agents=[travel_planner_agent],
       tasks=[task],
   )
   # Execute the crew and obtain results
   travel_plan = crew.kickoff()
   return travel_plan

Let’s try out the system, here we are hard coding the travel parameters but you could take them as input from users:

travel_plan = plan_travel_itinerary(
   destination='Abu Dhabi, UAE',
   duration_days=5,
   budget_usd=2000,
   interests=['adventure', 'cuisine', 'architecture'],
)
print(travel_plan.raw)

The output:

**5-Day Travel Itinerary for Abu Dhabi, UAE on a $2000 Budget**
**Day 1: Arrival and Initial Exploration**
- **Morning:**
 - Arrive at Abu Dhabi International Airport.
 - Transfer to your hotel (budget-friendly options: Premier Inn Abu Dhabi International Airport Hotel or Centro Yas Island).
 - Check-in and freshen up.
- **Afternoon:**
 - Visit Sheikh Zayed Grand Mosque (Free Entry).
 - Explore the stunning architecture and learn about Islamic culture.
- **Evening:**
 - Dine at Al Fanar Restaurant & Cafe for traditional Emirati cuisine.
 - Cost: ~$30
**Day 2: Adventure and City Tour**
- **Morning:**
 - Breakfast at the hotel.
 - Head to Ferrari World Abu Dhabi.
 - Experience thrilling rides and the world's fastest roller coaster.
 - Cost: ~$80
- **Afternoon:**
 - Lunch at Il Podio in Ferrari World.
 - Cost: ~$25
 - Visit Yas Marina Circuit for a guided tour of the Formula 1 track.
 - Cost: ~$60
- **Evening:**
 - Dinner at Yas Island's Cipriani for Italian cuisine with a view.
 - Cost: ~$60
**Day 3: Cultural and Architectural Delights**
- **Morning:**
 - Breakfast at the hotel.
 - Visit Qasr Al Watan, the Presidential Palace.
 - Explore the stunning architecture and exhibitions.
 - Cost: ~$15
- **Afternoon:**
 - Lunch at Cafe Milano, located in the Four Seasons Hotel.
 - Cost: ~$40
 - Visit the Louvre Abu Dhabi.
 - Discover a blend of art, culture, and impressive architecture.
 - Cost: ~$17
- **Evening:**
 - Dinner at Li Beirut, a fine-dining Lebanese restaurant.
 - Cost: ~$50
**Day 4: Desert Adventure**
- **Morning:**
 - Breakfast at the hotel.
 - Relax and enjoy the hotel amenities or a brief city walk.
- **Afternoon:**
 - Lunch at a local restaurant (budget option: Zahrat Lebnan).
 - Cost: ~$15
 - Embark on a Desert Safari Adventure.
 - Activities include dune bashing, sandboarding, camel riding, and a BBQ dinner.
 - Cost: ~$100
- **Evening:**
 - Enjoy the desert camp entertainment and dinner.
 - Return to the hotel late in the evening.
**Day 5: Souk Shopping and Departure**
- **Morning:**
 - Breakfast at the hotel.
 - Visit the Heritage Village for a glimpse into traditional Bedouin life.
 - Free Entry.
- **Afternoon:**
 - Lunch at Al Dhafra Restaurant, featuring traditional Emirati cuisine.
 - Cost: ~$30
 - Explore the Abu Dhabi Souk for last-minute shopping.
 - Purchase souvenirs and local handicrafts.
- **Evening:**
 - Return to the hotel, check out, and transfer to the airport.
 - Departure from Abu Dhabi International Airport.
**Estimated Total Cost:**
- Accommodation: ~$400 (5 nights at a budget hotel)
- Meals: ~$285
- Activities and Entrance Fees: ~$337
- Transport (local taxis, transfers): ~$200
- Miscellaneous/Souvenirs: ~$100
**Total: ~$1322 (leaving room for flexibility within the $2000 budget)**
Enjoy your adventure-filled and culturally immersive trip to Abu Dhabi!

Not bad is it! It came up with a very comprehensive plan considering user’s parameters, especially well keeping within budget constraints.

Implementing A Multi-Agent System

For our multi-agent system example, we’ll develop a game development system involving software and Quality Assurance engineers. The system will take a game description and write Python code for it.

First, let’s define the agents: a software engineer agent, a QA engineer agent, and a chief QA engineer agent, using two QAs to ensure the produced code quality is top-notch.

software_engineer_agent = Agent(
   role='Senior Software Engineer',
   goal='Create software as needed',
   backstory="""
       You are a Senior Software Engineer at a leading tech think tank.
       Your expertise in programming in python. and do your best to
       produce perfect code
   """,
   allow_delegation=False,
)
qa_engineer_agent = Agent(
   role='Software Quality Control Engineer',
   goal='create prefect code, by analizing the code that is given for errors',
   backstory="""
       You are a software engineer that specializes in checking code for errors.
       You have an eye for detail and a knack for finding hidden bugs.
       You check for missing imports, variable declarations, mismatched brackets and syntax errors.
       You also check for security vulnerabilities, and logic errors""",
   allow_delegation=False,
)
chief_qa_engineer_agent = Agent(
   role='Chief Software Quality Control Engineer',
   goal='Ensure that the code does the job that it is supposed to do',
   backstory="""
       You feel that programmers always do only half the job, so you are
       super dedicated to make high quality code.
   """,
   allow_delegation=True,
)

For the tasks, we have used an object-oriented approach to simplify task initialization, as each task requires a different agent. We have defined a code task, a review task, and an evaluate task:

class GameTasks:
@staticmethod
def code_task(agent, instructions):
 return Task(
  description=f"""
   You will create a game using python, be as simple as possible, prefer using simpler and builtin python libraries
   like turtle instead of pygame but feel free to use advanced libraries if required. These are the instructions:
   Instructions
   ------------
   {instructions}
   Your Final answer must be the full python code, only the python code and nothing else.
  """,
  agent=agent,
  expected_output="Full Python code for the game, only the python code and nothing else."
 )
@staticmethod
def review_task(agent, instructions):
 return Task(
  description=f"""
   You are helping create a game using python, these are the instructions:
   Instructions
   ------------
   {instructions}
   Using the code you got, check for errors. Check for logic errors,
   syntax errors, missing imports, variable declarations, mismatched brackets,
   and security vulnerabilities.
a
   Your Final answer must be the full python code, only the python code and nothing else.
  """,
  agent=agent,
  expected_output="Full Python code for the game, only the python code and nothing else."
 )
@staticmethod
def evaluate_task(agent, instructions):
 return Task(
  description=f"""
   You are helping create a game using python, these are the instructions:
   Instructions
   ------------
   {instructions}
   You will look over the code to insure that it is complete and
   does the job that it is supposed to do.
   Your Final answer must be the full python code, only the python code and nothing else.
  """,
  agent=agent,
  expected_output="Full Python code for the game, only the python code and nothing else."
 )

Finally, we define the function that creates and runs the the crew:

def develop_game(instructions):
   crew = Crew(
       agents=[
           software_engineer_agent,
           qa_engineer_agent,
           chief_qa_engineer_agent,
       ],
       tasks = [
           GameTasks.code_task(software_engineer_agent, instructions),
           GameTasks.review_task(qa_engineer_agent, instructions),
           GameTasks.evaluate_task(chief_qa_engineer_agent, instructions),
       ]
   )

   result = crew.kickoff()
   game_code = result.raw
   return game_code

Let’s try it out! We will attempt to create a Snake game as an example.

game_instructions = """
A Snake game. User plays as and controls the snake moves which around the screen and grows longer by eating food.
The game ends if the snake collides with itself or the walls/edges. It includes a score counter and an option to
restart by pressing Enter.
"""
game_code = develop_game(game_instructions)
print(game_code)

The code is too long to show here, but here’s a screenshot of the result of running the produced game code, and it works surprisingly well!

So now you have a brief overview of how to create agentic systems. We encourage you to experiment with CrewAI for your own ideas, such as an Instagram post writer, a stock analyzer, or any other agentic system concept you can imagine. Just think about the agents you need, the tasks they should perform, and assemble them using CrewAI. You can also check out CrewAI’s documentation (https://docs.crewai.com/) for additional features that might assist you as you build larger and more complex systems.

Potential Impact and Future of AI Agents

Having explored the theoretical and practical fundamentals of agentic AI, we now turn our attention to the exciting future of AI agents. Now, we will explore how the field is emerging and its potential to have a transformative impact on AI.

Outperforming Larger Models With Smaller Ones

One of the major selling points of AI agents is their ability to boost the performance of LLMs to such an extent that they enable smaller language models to perform comparably to larger ones. This capability was highlighted in the HumanEval Benchmark, which focuses on coding tasks. The figure below illustrates the benchmark results, showing how GPT-3.5 and GPT-4 perform alone (labelled as zero-shot) or with agentic workflows (the other labels). The results show that all agentic versions of GPT-3.5 outperform the zero-shot prompting of GPT-4. This implies that users can leverage smaller, cheaper models like GPT-3.5 to achieve performance comparable to or even better than higher models like GPT-4. They can also use an existing model to match the performance of anticipated upcoming models, like GPT-5 (or whatever OpenAI ends up naming their next LLM). This capability is particularly useful in scenarios where a self-hosted model is employed to maintain data privacy; in such cases, limited compute power may hinder performance compared to large models from companies like Google or OpenAI. However, using agentic workflows on small self-hosted models can deliver comparable results to said large models.

A Rapidly Growing Paradigm

The 2024 Hype Cycle for Artificial Intelligence report by Gartner, which provides an overview of the current state and potential of various AI domains and paradigms, indicates that agentic systems are in the early stages of gaining momentum and are set for substantial growth. This suggests that agent-based systems are on the verge of major breakthroughs and are expected to deliver significant value and innovation in the near future.

Possible Path to AGI

The rise of AI in recent years has been accompanied by growing discussions about Artificial General Intelligence (AGI). Some predict that generative AI models might form the foundation of what will eventually become AGI. If these generative AI-based models are to approach AGI or come close to it, it is highly likely that agentic workflows will play a significant role. The iterative and collaborative nature of these workflows has the potential to be essential in expanding generative AI capabilities and advancing progress toward AGI.

Inference Speed Bottleneck

A significant factor that could impede the progress and widespread adoption of AI agents is the token generation speed of LLMs —agents’ iterative nature is what causes this bottleneck in efficient interactions. Therefore, optimising inference speed is crucial.

To enhance the response times of LLMs, the following approaches can be considered:

1. Inference optimization — Improve the software running the model by approaches such as removing redundant computations, organising data more efficiently, and using better algorithms.
2. Reduce model size — Use smaller models that need less computation and memory by applying techniques such as low-rank optimization, knowledge distillation, and quantization.
3. Improve hardware — Opt for specialised hardware like GPUs or TPUs, which are better suited for the mathematical tasks that LLMs need to perform compared to regular CPUs.

An example of a fast AI inference solution is Groq. Groq uses a unique technology called “LPU AI inference” that offers quick, affordable, and energy-efficient performance. Its token generation speed surpasses human reading speed, which, while not much beneficial for normal single-shot prompting interactions, could greatly enhance iterative prompting and inter-agent collaboration, making agentic workflows appear more seamless and responsive. Groq offers both cloud and on-premises solutions for scalable AI applications. For more information, visit Groq’s website at https://wow.groq.com/.

Challenges and Considerations

While the future looks bright for agents, there are some challenges to consider in addition to inference speed, such as:

• Patience is Key: Unlike traditional LLM interactions, agentic workflows are iterative, and results may take time. Patience is required when working with AI agents.
• Continuous Development: Ongoing development and refinement in all aspects of agentic technologies will be necessary to unlock their full potential, as with any new technology.
• Realistic Expectations: It’s important to recognize that agentic workflows, while promising, are not a cure-all solution. Being generative AI based systems, they may still encounter challenges inherent to such systems, such as biases and fuzzy outputs. While agents can improve these aspects, complete elimination of such issues cannot be guaranteed.
• Ethical & Security Implications: As AI systems become increasingly autonomous, significant ethical concerns arise regarding accountability for negative outcomes. Additionally, if not properly managed, these systems could act unpredictably, causing various types of damage. Therefore, it is essential to implement guardrails to adhere to ethical standards and mitigate security risks.

Agents represent a significant advancement in the evolution of Artificial Intelligence. As Andrew Ng (leading AI researcher, computer scientist, and educator) suggests, agentic workflows hold the key to unlocking the true power of AI.

This concludes our topic of Agentic AI. We hope it has provided you with a comprehensive understanding of this groundbreaking technology and its potential to revolutionise various aspects of our lives, and that you are as excited about its future as we are!