steps performed by problem solving agent in ai

• Data Science
• Data Analysis
• Data Visualization
• Machine Learning
• Deep Learning
• Computer Vision
• Artificial Intelligence
• AI ML DS Interview Series
• AI ML DS Projects series
• Data Engineering
• Web Scrapping

Problem Solving in Artificial Intelligence

The reflex agent of AI directly maps states into action. Whenever these agents fail to operate in an environment where the state of mapping is too large and not easily performed by the agent, then the stated problem dissolves and sent to a problem-solving domain which breaks the large stored problem into the smaller storage area and resolves one by one. The final integrated action will be the desired outcomes.

On the basis of the problem and their working domain, different types of problem-solving agent defined and use at an atomic level without any internal state visible with a problem-solving algorithm. The problem-solving agent performs precisely by defining problems and several solutions. So we can say that problem solving is a part of artificial intelligence that encompasses a number of techniques such as a tree, B-tree, heuristic algorithms to solve a problem.  

We can also say that a problem-solving agent is a result-driven agent and always focuses on satisfying the goals.

There are basically three types of problem in artificial intelligence:

1. Ignorable: In which solution steps can be ignored.

2. Recoverable: In which solution steps can be undone.

3. Irrecoverable: Solution steps cannot be undo.

Steps problem-solving in AI: The problem of AI is directly associated with the nature of humans and their activities. So we need a number of finite steps to solve a problem which makes human easy works.

These are the following steps which require to solve a problem :

• Problem definition: Detailed specification of inputs and acceptable system solutions.
• Problem analysis: Analyse the problem thoroughly.
• Knowledge Representation: collect detailed information about the problem and define all possible techniques.
• Problem-solving: Selection of best techniques.

Components to formulate the associated problem: 

• Initial State: This state requires an initial state for the problem which starts the AI agent towards a specified goal. In this state new methods also initialize problem domain solving by a specific class.
• Action: This stage of problem formulation works with function with a specific class taken from the initial state and all possible actions done in this stage.
• Transition: This stage of problem formulation integrates the actual action done by the previous action stage and collects the final stage to forward it to their next stage.
• Goal test: This stage determines that the specified goal achieved by the integrated transition model or not, whenever the goal achieves stop the action and forward into the next stage to determines the cost to achieve the goal.  
• Path costing: This component of problem-solving numerical assigned what will be the cost to achieve the goal. It requires all hardware software and human working cost.

Please Login to comment...

Similar reads.

• 105 Funny Things to Do to Make Someone Laugh
• Best PS5 SSDs in 2024: Top Picks for Expanding Your Storage
• Best Nintendo Switch Controllers in 2024
• Xbox Game Pass Ultimate: Features, Benefits, and Pricing in 2024
• #geekstreak2024 – 21 Days POTD Challenge Powered By Deutsche Bank

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Problem Solving Agents in Artificial Intelligence

In this post, we will talk about Problem Solving agents in Artificial Intelligence, which are sort of goal-based agents. Because the straight mapping from states to actions of a basic reflex agent is too vast to retain for a complex environment, we utilize goal-based agents that may consider future actions and the desirability of outcomes.

You Will Learn

Problem Solving Agents

Problem Solving Agents decide what to do by finding a sequence of actions that leads to a desirable state or solution.

An agent may need to plan when the best course of action is not immediately visible. They may need to think through a series of moves that will lead them to their goal state. Such an agent is known as a problem solving agent , and the computation it does is known as a search .

The problem solving agent follows this four phase problem solving process:

• Goal Formulation: This is the first and most basic phase in problem solving. It arranges specific steps to establish a target/goal that demands some activity to reach it. AI agents are now used to formulate goals.
• Problem Formulation: It is one of the fundamental steps in problem-solving that determines what action should be taken to reach the goal.
• Search: After the Goal and Problem Formulation, the agent simulates sequences of actions and has to look for a sequence of actions that reaches the goal. This process is called search, and the sequence is called a solution . The agent might have to simulate multiple sequences that do not reach the goal, but eventually, it will find a solution, or it will find that no solution is possible. A search algorithm takes a problem as input and outputs a sequence of actions.
• Execution: After the search phase, the agent can now execute the actions that are recommended by the search algorithm, one at a time. This final stage is known as the execution phase.

Problems and Solution

Before we move into the problem formulation phase, we must first define a problem in terms of problem solving agents.

A formal definition of a problem consists of five components:

Initial State

Transition model.

It is the agent’s starting state or initial step towards its goal. For example, if a taxi agent needs to travel to a location(B), but the taxi is already at location(A), the problem’s initial state would be the location (A).

It is a description of the possible actions that the agent can take. Given a state s, Actions ( s ) returns the actions that can be executed in s. Each of these actions is said to be appropriate in s.

It describes what each action does. It is specified by a function Result ( s, a ) that returns the state that results from doing action an in state s.

The initial state, actions, and transition model together define the state space of a problem, a set of all states reachable from the initial state by any sequence of actions. The state space forms a graph in which the nodes are states, and the links between the nodes are actions.

It determines if the given state is a goal state. Sometimes there is an explicit list of potential goal states, and the test merely verifies whether the provided state is one of them. The goal is sometimes expressed via an abstract attribute rather than an explicitly enumerated set of conditions.

It assigns a numerical cost to each path that leads to the goal. The problem solving agents choose a cost function that matches its performance measure. Remember that the optimal solution has the lowest path cost of all the solutions .

Example Problems

The problem solving approach has been used in a wide range of work contexts. There are two kinds of problem approaches

• Standardized/ Toy Problem: Its purpose is to demonstrate or practice various problem solving techniques. It can be described concisely and precisely, making it appropriate as a benchmark for academics to compare the performance of algorithms.
• Real-world Problems: It is real-world problems that need solutions. It does not rely on descriptions, unlike a toy problem, yet we can have a basic description of the issue.

Some Standardized/Toy Problems

Vacuum world problem.

Let us take a vacuum cleaner agent and it can move left or right and its jump is to suck up the dirt from the floor.

The vacuum world’s problem can be stated as follows:

States: A world state specifies which objects are housed in which cells. The objects in the vacuum world are the agent and any dirt. The agent can be in either of the two cells in the simple two-cell version, and each call can include dirt or not, therefore there are 2×2×2 = 8 states. A vacuum environment with n cells has n×2 n states in general.

Initial State: Any state can be specified as the starting point.

Actions: We defined three actions in the two-cell world: sucking, moving left, and moving right. More movement activities are required in a two-dimensional multi-cell world.

Transition Model: Suck cleans the agent’s cell of any filth; Forward moves the agent one cell forward in the direction it is facing unless it meets a wall, in which case the action has no effect. Backward moves the agent in the opposite direction, whilst TurnRight and TurnLeft rotate it by 90°.

Goal States: The states in which every cell is clean.

Action Cost: Each action costs 1.

8 Puzzle Problem

In a sliding-tile puzzle , a number of tiles (sometimes called blocks or pieces) are arranged in a grid with one or more blank spaces so that some of the tiles can slide into the blank space. One variant is the Rush Hour puzzle, in which cars and trucks slide around a 6 x 6 grid in an attempt to free a car from the traffic jam. Perhaps the best-known variant is the 8- puzzle (see Figure below ), which consists of a 3 x 3 grid with eight numbered tiles and one blank space, and the 15-puzzle on a 4 x 4  grid. The object is to reach a specified goal state, such as the one shown on the right of the figure. The standard formulation of the 8 puzzles is as follows:

STATES : A state description specifies the location of each of the tiles.

INITIAL STATE : Any state can be designated as the initial state. (Note that a parity property partitions the state space—any given goal can be reached from exactly half of the possible initial states.)

ACTIONS : While in the physical world it is a tile that slides, the simplest way of describing action is to think of the blank space moving Left , Right , Up , or Down . If the blank is at an edge or corner then not all actions will be applicable.

TRANSITION MODEL : Maps a state and action to a resulting state; for example, if we apply Left to the start state in the Figure below, the resulting state has the 5 and the blank switched.

GOAL STATE :  It identifies whether we have reached the correct goal state. Although any state could be the goal, we typically specify a state with the numbers in order, as in the Figure above.

ACTION COST : Each action costs 1.

You Might Like:

• Agents in Artificial Intelligence

Types of Environments in Artificial Intelligence

• Understanding PEAS in Artificial Intelligence
• River Crossing Puzzle | Farmer, Wolf, Goat and Cabbage

Share Article:

Digital image processing: all you need to know.

Understanding Problem Solving Agents in Artificial Intelligence

Have you ever wondered how artificial intelligence systems are able to solve complex problems? Problem solving agents play a key role in AI, using algorithms and strategies to find solutions to a variety of challenges.

Problem-solving agents in artificial intelligence are a type of agent that are designed to solve complex problems in their environment. They are a core concept in AI and are used in everything from games like chess to self-driving cars.

In this blog, we will explore problem solving agents in artificial intelligence, types of problem solving agents in AI, real-world applications, and many more.

Table of Contents

What is problem solving agents in artificial intelligence, type 1: simple reflex agents, type 2: model-based agents, type 3: goal-based agents, 2. knowledge base, 3. reasoning engine, 4. actuators, gaming agents, virtual assistants, recommendation systems, scheduling and planning.

A Problem-Solving Agent is a special computer program in Artificial Intelligence. It can perceive the world around it through sensors. Sensors help it gather information.

The agent processes this information using its knowledge base. A knowledge base is like the agent’s brain. It stores facts and rules. Using its knowledge, the agent can reason about the best actions. It can then take those actions to achieve goals.

In simple words, a Problem-Solving Agent observes its environment. It understands the situation. Then it figures out how to solve problems or finish tasks.

These agents use smart algorithms. The algorithms allow them to think and act like humans. Problem-solving agents are very important in AI. They help tackle complex challenges efficiently.

Types of Problem Solving Agents in AI

There are different types of Problem Solving Agents in AI. Each type works in its own way. Below are the different types of problem solving agents in AI:

Simple Reflex Agents are the most basic kind. They simply react to the current situation they perceive. They don’t consider the past or future.

For example, a room thermostat is a Simple Reflex Agent. It turns the heat on or off based only on the current room temperature.

Model-based agents are more advanced. They create an internal model of their environment. This model helps them track how the world changes over time.

Using this model, they can plan ahead for future situations. Self-driving cars use Model-Based Agents to predict how traffic will flow.

Goal-based agents are the most sophisticated type. They can set their own goals and figure out sequences of actions to achieve those goals.

These agents constantly update their knowledge as they pursue their goals. Virtual assistants like Siri or Alexa are examples of Goal-Based Agents assisting us with various tasks.

Each type has its own strengths based on the problem they need to solve. Simple problems may just need Reflex Agents, while complex challenges require more advanced Model-Based or Goal-Based Agents.

Components of a Problem Solving Agent in AI

A Problem Solving Agent has several key components that work together. Let’s break them down:

Sensors are like the agent’s eyes and ears. They collect information from the environment around the agent. For example, a robot’s camera and motion sensors act as sensors.

The Knowledge Base stores all the facts, rules, and information the agent knows. It’s like the agent’s brain full of knowledge. This knowledge helps the agent understand its environment and make decisions.

The Reasoning Engine is the thinking part of the agent. It processes the information from sensors using the knowledge base. The reasoning engine then figures out the best action to take based on the current situation.

Finally, Actuators are like the agent’s hands and limbs. They carry out the actions decided by the reasoning engine. For a robot, wheels and robotic arms would be its actuators.

All these components work seamlessly together. Sensors gather data, the knowledge base provides context, the reasoning engine makes a plan, and actuators implement that plan in the real world.

Real-world Applications of Problem Solving Agents in AI

Problem Solving Agents are not just theoretical concepts. They are actively used in many real-world applications today. Let’s look at some examples:

Problem solving agents are widely used in gaming applications. They can analyze the current game state, consider possible future moves, and make the optimal play. This allows them to beat human players in complex games like chess or go.

Robots in factories and warehouses heavily rely on problem solving agents. These agents perceive the environment around the robot using sensors. They then plan efficient paths and control the robot’s movements and actions accordingly.

Smart home devices like Alexa or Google Home use goal-based problem solving agents. They can understand your requests, look up relevant information from their knowledge base, and provide useful responses to assist you.

Online retailers suggest products you may like based on recommendations from problem solving agents. These agents analyze your past purchases and preferences to make personalized product suggestions.

Scheduling apps help plan your day efficiently using problem solving techniques. The agents consider your appointments, priorities, and travel time to optimize your daily schedule.

Self-Driving Cars One of the most advanced applications is self-driving cars. Their problem solving agents continuously monitor surroundings, predict the movements of other vehicles and objects, and navigate roads safely without human intervention.

In conclusion, Problem solving agents are at the heart of artificial intelligence, mimicking human-like reasoning and decision-making. From gaming to robotics, virtual assistants to self-driving cars, these intelligent agents are already transforming our world. As researchers continue pushing the boundaries, problem solving agents will become even more advanced and ubiquitous in the future. Exciting times lie ahead as we unlock the full potential of this remarkable technology.

Ajay Rathod loves talking about artificial intelligence (AI). He thinks AI is super cool and wants everyone to understand it better. Ajay has been working with computers for a long time and knows a lot about AI. He wants to share his knowledge with you so you can learn too!

5 thoughts on “Understanding Problem Solving Agents in Artificial Intelligence”

• Pingback: What Is Explanation Based Learning in Artificial Intelligence?

Can you be more specific about the content of your article? After reading it, I still have some doubts. Hope you can help me.

Thanks for sharing. I read many of your blog posts, cool, your blog is very good.

Truly appreciate your well-written posts. I have certainly picked up valuable insights from your page. Here is mine UQ6 about Thai-Massage. Feel free to visit soon.

Leave a comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

Thanks, I’m not interested

Problem-Solving Agents In Artificial Intelligence

In artificial intelligence, a problem-solving agent refers to a type of intelligent agent designed to address and solve complex problems or tasks in its environment. These agents are a fundamental concept in AI and are used in various applications, from game-playing algorithms to robotics and decision-making systems. Here are some key characteristics and components of a problem-solving agent:

• Perception : Problem-solving agents typically have the ability to perceive or sense their environment. They can gather information about the current state of the world, often through sensors, cameras, or other data sources.
• Knowledge Base : These agents often possess some form of knowledge or representation of the problem domain. This knowledge can be encoded in various ways, such as rules, facts, or models, depending on the specific problem.
• Reasoning : Problem-solving agents employ reasoning mechanisms to make decisions and select actions based on their perception and knowledge. This involves processing information, making inferences, and selecting the best course of action.
• Planning : For many complex problems, problem-solving agents engage in planning. They consider different sequences of actions to achieve their goals and decide on the most suitable action plan.
• Actuation : After determining the best course of action, problem-solving agents take actions to interact with their environment. This can involve physical actions in the case of robotics or making decisions in more abstract problem-solving domains.
• Feedback : Problem-solving agents often receive feedback from their environment, which they use to adjust their actions and refine their problem-solving strategies. This feedback loop helps them adapt to changing conditions and improve their performance.
• Learning : Some problem-solving agents incorporate machine learning techniques to improve their performance over time. They can learn from experience, adapt their strategies, and become more efficient at solving similar problems in the future.

Problem-solving agents can vary greatly in complexity, from simple algorithms that solve straightforward puzzles to highly sophisticated AI systems that tackle complex, real-world problems. The design and implementation of problem-solving agents depend on the specific problem domain and the goals of the AI application.

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Which Of The Following Is A Privilege In SQL Standard

Implicit Return Type Int In C

Leave a Comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

Reach Out to Us for Any Query

SkillVertex is an edtech organization that aims to provide upskilling and training to students as well as working professionals by delivering a diverse range of programs in accordance with their needs and future aspirations.

© 2024 Skill Vertex

Latest Cloud, Data, DevOps Technologies

• Artificial Intelligence

What is the problem-solving agent in artificial intelligence?

Are you curious to know how machines can solve complex problems, just like humans? Enter the world of artificial intelligence and meet one of its most critical players- the Problem-Solving Agent. In this blog post, we’ll explore what a problem-solving agent is, how it works in AI systems and some exciting real-world applications that showcase its potential. So, buckle up for an insightful journey into the fascinating world of AI problem solvers!

Problem-solving in artificial intelligence can be quite complex, requiring the use of multiple algorithms and data structures. One critical player is the Problem-Solving Agent, which helps machines find solutions to problems. In this blog post, we’ll explore what a problem-solving agent is, how it works in AI systems and some exciting real-world applications that showcase its potential. So, buckle up for an insightful journey into the fascinating world of AI problem solvers!

Table of Contents

What is Problem Solving Agent?

Problem-solving in artificial intelligence is the process of finding a solution to a problem. There are many different types of problems that can be solved, and the methods used will depend on the specific problem. The most common type of problem is finding a solution to a maze or navigation puzzle.

Other types of problems include identifying patterns, predicting outcomes, and determining solutions to systems of equations. Each type of problem has its own set of techniques and tools that can be used to solve it.

There are three main steps in problem-solving in artificial intelligence:

1) understanding the problem: This step involves understanding the specifics of the problem and figuring out what needs to be done to solve it.

2) generating possible solutions: This step involves coming up with as many possible solutions as possible based on information about the problem and what you know about how computers work.

3) choosing a solution: This step involves deciding which solution is best based on what you know about the problem and your options for solving it.

Types of Problem-Solving Agents

Problem-solving agents are a type of artificial intelligence that helps automate problem-solving. They can be used to solve problems in natural language, algebra, calculus, statistics, and machine learning.

There are three types of problem-solving agents: propositional, predicate, and automata. Propositional problem-solving agents can understand simple statements like “draw a line between A and B” or “find the maximum value of x.” Predicate problem-solving agents can understand more complex statements like “find the shortest path between two points” or “find all pairs of snakes in a jar.” Automata is the simplest form of problem-solving agent and can only understand sequences of symbols like “draw a square.”

Classification of Problem-Solving Agents

Problem-solving agents can be classified as general problem solvers or domain-specific problem solvers. General problem solvers can solve a wide range of problems, while domain-specific problem solvers are better suited for solving specific types of problems.

General problem solvers include AI programs that are designed to solve general artificial intelligence (AI) problems such as learning how to navigate a 3D environment or playing games. Domain-specific problem solvers include programs that have been specifically tailored to solve certain types of problems, such as photo editing or medical diagnosis.

Both general and domain-specific problem-solving agents can be used in conjunction with other AI tools, including natural language processing (NLP) algorithms and machine learning models. By combining these tools, we can achieve more effective and efficient outcomes in our data analysis and machine learning processes.

Applications of Problem-Solving Agents

Problem-solving agents can be used in a number of different ways in artificial intelligence. They can be used to help find solutions to specific problems or tasks, or they can be used to generalize a problem and find potential solutions. In either case, the problem-solving agent is able to understand complex instructions and carry out specific tasks.

Problem-solving is an essential skill for any artificial intelligence developer. With AI becoming more prevalent in our lives, it’s important that we have a good understanding of how to approach and solve problems. In this article, we’ll discuss some common problem-solving techniques and provide you with tips on how to apply them when developing AI applications. By applying these techniques systematically, you can build robust AI solutions that work correctly and meet the needs of your users.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Related Articles

Intel AI openVino toolkit

NVIDIA GPU FOR THE GOOGLE CLOUD PLATFORM

Nvidia GPU family for Deep Learning

INTEL AI-BASED DEVELOPMENT

Problem-Solving AI Agents

I started studying, again. October marked my new beginning at University of Pisa, as a student of the AI curriculum for the Computer Science Master's degree . I decided to begin from the Artificial Intelligence Fundamentals course which goal is to give us the fundamentals of the AI discipline. Starting from the definition of a rational agent, we will dive in into the concepts of reasoning, planning and solving problems, searching for solutions to them.

One of the first issues that an AI practicioner has to face is to understand and define as clearly as possible the environment of its problem. There are some framework that helps to standardize that definition, but you can easily imagine what are the main aspects to take attention to. One of those is the knowledge of the environment upon which the problem relies. For example, would be great to predict the presence of a disease from a simple blood analysis, and that's the case for some of them. But there are certainly some disease for which we didn't found yet a systematic correlation between values and prediction. In those cases, technologies like AI comes in help. That was an example in which there is a lack of knowledge, but you can also be faced with a real lack of visibility : let's think of a maze for example, or maybe a robot that wants to clean your house. It does not know the house "structure" before making an exploration phase. So, as you can imagine, there are a lot of possibilities here, both from the environment point of view, both from the instruments that you have to choose while addressing the problem.

The concepts in that course start to look at those problems relaxing the real-world scenarios, investigating abstract and simplified environment first. So, let's imagine ourselves in a fully observable environment. That means that in every moment, we are able to have a complete point of view upon the whole problem, aware of all the information that we need to solve it . At the same time, though, we also know that we are not able to immediately tell with certainty what's the correct action to take to reach our goal. With that environment in front of us, the correct instrument to use are the so called problem-solving agent , which strategy is to plan ahead and consider a path that bring them from a starting point toward the goal state. That process is known (by all of us) as search .

Let's give us an example problem now: we are a little funny cell of a grid. We know that this grid has a maze, and we also know that we want to find our friend, that is somewhere inside the grid. Lastly, thanks to our drone, we also have a clear view from the top of the grid that gives us the whole knowledge of the current situation of our environment.

First thing to do, we have to formalize the problem as a search problem:

• What are the states on which the environment can be in? Defining the state space , we can say that it is composed by the set of the grid's cell coordinates.
• What's the initial state ? It's where we are right know, the coordinates of our position in the grid.
• What is the goal ? Is there only one of it? We have to find our friend, so our goal will be the coordinates of our friend in the grid.
• What are the actions that we can take? Well, generally speaking we can go ahead toward the top, right, bottom or left cell. In that case, we should be careful to not step on the walls of our maze, though.
• What is the effect of our action on the environment? Also called the transition model , it serves us to explain what is the state resulting from a certain action taken from a certain state. We know this, we just need to update our coordinates based on the direction of the movement.
• What is the cost of our actions? For example, let's imagine a navigator agent. We need to know how much kilometers is long every available roads towards our goal to minimize the costs for our passenger (actually, maybe would be worth to focus on the time, but it's just an example).

Okay, we should have everything now to solve our problem. As we already said we need to find the correct sequence of actions that brings the agent from the initial state to the goal state . The agent will find it building a search tree where:

• the root of the tree is the initial state;
• on every state, the agent will consider all the legal actions that can be taken from that state (we formalized this information before) and will take them, expanding the current node to create different branches of the tree;
• all the current leaves node, form the so-called frontier , i.e. the list of nodes that can be expanded in the subsequent search step. Which node will be chosen by the agent from the frontier is what characterizes the chosen searching algorithm. This is one of the most important choice to make when designing the agent;
• when a node is chosen from the frontier for the expansion, the agent will check if that node encodes the goal state . If so, the search is ended and the problem's solved!

Let's bring that theory to a practical example. Supposing we have a 3x4 grid, with a starting and a goal position well defined.

So, as you can see the initial state is (3,4) while our goal is (1,2) . At the beginning of the searching process, our frontier will be made out of only the initial state.

• Choose a node from the frontier. How? Let's just randomize this choice right know, we will later see different strategies that we can adopt in that step. Anyway, at the beginning we will have only one choice: the initial state.
• Is this a goal state? Nope, so we have to take the actions phase.
• What are the legal actions that we can take from the current state? In this particular case, we are in (3,4) so we can only go up and toward the left.
• Taking all the available actions, we will expand the tree and put those resulting nodes (obtained by adding 1 to the right coordinate, as described by our transition model) in our frontier;
• New iteration!

When a goal state is found, we just need to backtrack using the parent property to build all the way up the solution path.

I have made up an image that could help us to grasp a bit more around the search loop described above, let's see and discuss it.

I feel like we need a legend here, so, at each iteration:

• the red nodes are the ones contained in the frontier;
• the blue nodes are the ones that have been already chosen and expanded;
• the orange outlined nodes are the one chosen from the frontier for the expansion;

You can also notice that there is a node outlined by a dashed red boxy rectangle . Looking at it, we can see that it seems to be a duplicate. Actually, it's not so right to use that duplicate word: we said that those nodes contains more information outside of the simple state that they encodes, like the cost of the path, the parent and so on. So, even if the encoded state is the same as the root, the nodes are pretty different! Anyway, it was important to highlight this possible situation, because could be part of the design process to implement some kind of strategy to avoid redundant paths like this one. Actually, there are some cases where this is a necessary choice to avoid infinite loop . My advice would be to always implement a strategy to avoid redundant path. The simplest way to do that would be to keep track of the visited state and avoid expansion that bring us again on those already checked. There are some cases, though, were this decision can be a little bit too greedy! That's because can happen that a path that we see as redundant maybe bring us to the same state with a better performance measure (i.e., with a lower cost). So, would be wise to keep track of the visited node, but also to check against them taking into account the cost spent to arrive there.

Great, so know we know the whole theory that we need, and we also understood that there are actually two main aspects in that search framework just presented:

• the strategy used to choice the node to expand from the frontier ;
• the strategy used to check for redundant paths during the search process;

These two things characterize the different search algorithms , that we can divide into two main categories:

• Uninformed search : the family of algorithms that does not exploit knowledge about what is known about the goal during the search process;
• Informed Search : the family of algorithms that exploit that knowledge to improve the quality of their search. With quality, we means maximize the performance measure of the agent (e.g., minimize time when using our Google Maps application).

Uninformed Search

Breadth-first search (bfs).

The idea of this algorithm is to explore broadly the search tree, checking all the nodes at a certain depth before going down on the tree. I labeled in that graphic the order in which the nodes would be visited by this algorithm:

From a practical point of view, this is implemented treating the frontier as a FIFO queue (for example, using the shift array method of Javascript when retrieving, assuming the use of push when inserting). Every time we want to expand a node, we have to choose the oldest one in the frontier. Talking about the strategy of checking against already visited nodes, we just need to check for the encoded state, without taking care of comparing the cost between the old and the redundant node. This is because, as per its nature, the Breadth First search algorithm ensure us that every time we visit a node, this has been visited through the optimal way (i.e., with the best performance measure).

Depth-First search (DFS)

Differently, as its name suggests, DFS algorithm tries to go as deep as possible before trying other branching routes. Again, here is a little graphic labeled to show you the order of visited nodes:

From a practical point of view, this is implemented treating the frontier as a LIFO queue (for example, using the pop array method of Javascript when retrieving, assuming the use of push when inserting). The idea is to expand always the last inserted node, the youngest one. Different is the issue with redundant paths here. First of all, it is extremely important to implement one, because this algorithm is very vulnerable to infinite loops . There is another issue, though: differently from the Breadth First search, DFS does not ensure us to find the optimal solution. For that reason, is really suggested to implement that redundant strategy not only checking against the state encoded in the node, but also using the current cost of the already visited state. Maybe that redundant path is better!

Dijkstra's algorithm

We are now moving over something that prove more reasoning. DFS and BFS have inside them a lot of mechanical-nature. They are systematic, and they face a great challenge when the state space is huge . We should start to think smarter, introducing a little bit of (artificial) intelligence. The Dijkstra's algorithm is still an uninformed algorithm, but at least it tries to exploit what it can knows about the environment: the frontier management strategy is to choose the node with the lower path cost (up to that moment). Now, let's make up another example with respect to the simple grid. That's because in the grid example every action has the same cost, so it's not so helpful to visualize the nature of this algorithm. Inspired from the AIMA example of Romanian roads, let's imagine this situation:

We are in Florence, and we want to reach the city of Lucca, following the instructions given by the Dijkstra's algorithm. The numbers on the arches are the costs of the roads (they are random, they don't recall the reality). That's the reasoning done by the algorithm:

• at the beginning we just have Florence in our frontier, let's expand it;
• we have two nodes in the frontier: Empoli, with a cost of 15, and Prato, with a cost of 10. The algorithm will choose the cheaper one: Prato! Expanding it, we put in the frontier Pistoia, with a cost of 30;
• we have two nodes in the frontier: Empoli, with a cost of 15, and Pistoia, with a cost of 30. Empoli is chosen and expanded. Now we have Lucca in the frontier, with a cost of 75. It is important to notice that, even though Lucca is our goal, we are not stopping here. That's because we can still find some better paths to it.
• we have two nodes in the frontier: Lucca, with a cost of 75, and Pistoia, with a cost of 30. Expanding Pistoia, we are ready for our last step!
• we have two nodes in the frontier: Lucca, with a cost of 75, and Lucca with a cost of 70. The chosen solution will then be Florence-Prato-Pistoia-Lucca one!

We have just experienced an interesting property of this algorithm. Even though we found a goal state earlier, we waited on labeling it as a solution, cause as long as we have some path with a lower cost, we could have potential solutions that are better!

Informed Search

Before presenting two of the most famous informed search algorithms, we need to define the meaning of that informed definition . The main idea is that the agent will exploit some kind of information about the goal state. This information is called heuristic . Defined as a function of the current node n , we can say that h(n) is the estimated cost from the node n toward our goal state. Now, there is a bunch of theory around those concepts, especially to prove optimality of some algorithms based on the heuristic's nature. By now, let's just assume those requirements for our heuristic function:

• the heuristic function is always greater than 0;
• the heuristic function of a goal state is equal to 0;
• the heuristic function of a node is always less or equal to the real optimal cost from that node to a goal state (i.e., the heuristic function is literally an optimistic estimation );

Now we can take a look at the two algorithms.

Greedy best-first search

The idea here is to choose from the frontier the nodes with lower heuristic value first. It seems to be reasonable: we know that the heuristic is an estimation of the real optimal cost, so, we prefer to focus on those nodes that seems to cost less toward our solution. Actually, this is not so straight-forward, and we can see why with an example. Then, we'll have pretty clear the reason of the greedy definition. Let's imagine this strange, but possible, situation:

First thing first, we should define our heuristic. For sake of simplicity, let's say that h(n) is the straight-line distance between the state n and the goal state (i.e., the red diamond). Okay now, supposing that our initial state is the green filled circle, the greedy approach will rather choose the state outlined by the purple circle with respect to the orange one. From there, it will follow the chain of states so close to the goal. If you sum the path cost, though, you can see that this path is worse than the other one. It is clear indeed what is the issue with that algorithm: it relies only on the estimation of the heuristic, without taking care of the actual cost needed to follow the current route.

A* Algorithm

To approach this limitation, the A* algorithm comes in our help. Its idea is to take into account, when choosing the node to expand, not only the value of the heuristic, but also the real cost to reach the node (it combines them computing the sum of those when evaluating nodes). Intuitively, we can understand that this algorithm will try to minimize the estimated cost to reach the goal while minimizing the actual cost of the solution path. This makes the A* algorithm not only complete, but also optimal (with the requirements that we put on our heuristic before). Recalling the previous example:

With respect to the path followed by the greedy approach, with the A* algorithm there will be a moment where the cost of the sub-optimal route will make the whole evaluation function greater with respect to the other one. This moment will be more or less around the nodes that I outlined with the light green ellipse . It is there that the A* will switch to the other path, finding the one that is actually optimal!

Introducing Searchy 🔎

If you have read my previous article, you already know that I don't like theory without practice. The goal of this article was to consolidate to myself the understanding of those concepts, as they are part of the program of my University's course. But while studying them, I thought would be cool to implement and visualize them from a concrete point of view. That is why I'm introducing to you my little side-project 🔎 Searchy .

🔎 Searchy wants to be an environment to test and visualize different problem-solving AI agents (i.e., searching algorithms) upon a simple problem as a fully-observable maze scenario. You can see a glance of it in that screenshot:

Right know, the usage is pretty simple: you have a grid, and you can customize the number of rows and columns. You can generate a randomized maze and the chosen algorithm will perform the search. Once the search is started, a couple of stats will be gathered during the process. Those are finally shown in the result section in the sidebar, together with the solution path on the grid.

My willingness is to open source this and try to continuously improve and evolve it to support less trivial scenarios, more algorithms, more insightful performance comparisons and so on. Would be good to have this application as a robust environment on which try, understand and test searching algorithms while studying those concepts.

📚 References

• Artificial Intelligence: a Modern Approach

💻 Practical References:

• Part 2 Problem-solving »
• Chapter 3 Solving Problems by Searching
• Edit on GitHub

Chapter 3 Solving Problems by Searching 

When the correct action to take is not immediately obvious, an agent may need to plan ahead : to consider a sequence of actions that form a path to a goal state. Such an agent is called a problem-solving agent , and the computational process it undertakes is called search .

Problem-solving agents use atomic representations, that is, states of the world are considered as wholes, with no internal structure visible to the problem-solving algorithms. Agents that use factored or structured representations of states are called planning agents .

We distinguish between informed algorithms, in which the agent can estimate how far it is from the goal, and uninformed algorithms, where no such estimate is available.

3.1 Problem-Solving Agents 

If the agent has no additional information—that is, if the environment is unknown —then the agent can do no better than to execute one of the actions at random. For now, we assume that our agents always have access to information about the world. With that information, the agent can follow this four-phase problem-solving process:

GOAL FORMULATION : Goals organize behavior by limiting the objectives and hence the actions to be considered.

PROBLEM FORMULATION : The agent devises a description of the states and actions necessary to reach the goal—an abstract model of the relevant part of the world.

SEARCH : Before taking any action in the real world, the agent simulates sequences of actions in its model, searching until it finds a sequence of actions that reaches the goal. Such a sequence is called a solution .

EXECUTION : The agent can now execute the actions in the solution, one at a time.

It is an important property that in a fully observable, deterministic, known environment, the solution to any problem is a fixed sequence of actions . The open-loop system means that ignoring the percepts breaks the loop between agent and environment. If there is a chance that the model is incorrect, or the environment is nondeterministic, then the agent would be safer using a closed-loop approach that monitors the percepts.

In partially observable or nondeterministic environments, a solution would be a branching strategy that recommends different future actions depending on what percepts arrive.

3.1.1 Search problems and solutions 

A search problem can be defined formally as follows:

A set of possible states that the environment can be in. We call this the state space .

The initial state that the agent starts in.

A set of one or more goal states . We can account for all three of these possibilities by specifying an \(Is\-Goal\) method for a problem.

The actions available to the agent. Given a state \(s\) , \(Actions(s)\) returns a finite set of actions that can be executed in \(s\) . We say that each of these actions is applicable in \(s\) .

A transition model , which describes what each action does. \(Result(s,a)\) returns the state that results from doing action \(a\) in state \(s\) .

An action cost function , denote by \(Action\-Cost(s,a,s\pr)\) when we are programming or \(c(s,a,s\pr)\) when we are doing math, that gives the numeric cost of applying action \(a\) in state \(s\) to reach state \(s\pr\) .

A sequence of actions forms a path , and a solution is a path from the initial state to a goal state. We assume that action costs are additive; that is, the total cost of a path is the sum of the individual action costs. An optimal solution has the lowest path cost among all solutions.

The state space can be represented as a graph in which the vertices are states and the directed edges between them are actions.

3.1.2 Formulating problems 

The process of removing detail from a representation is called abstraction . The abstraction is valid if we can elaborate any abstract solution into a solution in the more detailed world. The abstraction is useful if carrying out each of the actions in the solution is easier than the original problem.

3.2 Example Problems 

A standardized problem is intended to illustrate or exercise various problem-solving methods. It can be given a concise, exact description and hence is suitable as a benchmark for researchers to compare the performance of algorithms. A real-world problem , such as robot navigation, is one whose solutions people actually use, and whose formulation is idiosyncratic, not standardized, because, for example, each robot has different sensors that produce different data.

3.2.1 Standardized problems 

A grid world problem is a two-dimensional rectangular array of square cells in which agents can move from cell to cell.

Vacuum world

Sokoban puzzle

Sliding-tile puzzle

3.2.2 Real-world problems 

Route-finding problem

Touring problems

Trveling salesperson problem (TSP)

VLSI layout problem

Robot navigation

Automatic assembly sequencing

3.3 Search Algorithms 

A search algorithm takes a search problem as input and returns a solution, or an indication of failure. We consider algorithms that superimpose a search tree over the state-space graph, forming various paths from the initial state, trying to find a path that reaches a goal state. Each node in the search tree corresponds to a state in the state space and the edges in the search tree correspond to actions. The root of the tree corresponds to the initial state of the problem.

The state space describes the (possibly infinite) set of states in the world, and the actions that allow transitions from one state to another. The search tree describes paths between these states, reaching towards the goal. The search tree may have multiple paths to (and thus multiple nodes for) any given state, but each node in the tree has a unique path back to the root (as in all trees).

The frontier separates two regions of the state-space graph: an interior region where every state has been expanded, and an exterior region of states that have not yet been reached.

3.3.1 Best-first search 

In best-first search we choose a node, \(n\) , with minimum value of some evaluation function , \(f(n)\) .

3.3.2 Search data structures 

A node in the tree is represented by a data structure with four components

\(node.State\) : the state to which the node corresponds;

\(node.Parent\) : the node in the tree that generated this node;

\(node.Action\) : the action that was applied to the parent’s state to generate this node;

\(node.Path\-Cost\) : the total cost of the path from the initial state to this node. In mathematical formulas, we use \(g(node)\) as a synonym for \(Path\-Cost\) .

Following the \(PARENT\) pointers back from a node allows us to recover the states and actions along the path to that node. Doing this from a goal node gives us the solution.

We need a data structure to store the frontier . The appropriate choice is a queue of some kind, because the operations on a frontier are:

\(Is\-Empty(frontier)\) returns true only if there are no nodes in the frontier.

\(Pop(frontier)\) removes the top node from the frontier and returns it.

\(Top(frontier)\) returns (but does not remove) the top node of the frontier.

\(Add(node, frontier)\) inserts node into its proper place in the queue.

Three kinds of queues are used in search algorithms:

A priority queue first pops the node with the minimum cost according to some evaluation function, \(f\) . It is used in best-first search.

A FIFO queue or first-in-first-out queue first pops the node that was added to the queue first; we shall see it is used in breadth-first search.

A LIFO queue or last-in-first-out queue (also known as a stack ) pops first the most recently added node; we shall see it is used in depth-first search.

3.3.3 Redundant paths 

A cycle is a special case of a redundant path .

As the saying goes, algorithms that cannot remember the past are doomed to repeat it . There are three approaches to this issue.

First, we can remember all previously reached states (as best-first search does), allowing us to detect all redundant paths, and keep only the best path to each state.

Second, we can not worry about repeating the past. We call a search algorithm a graph search if it checks for redundant paths and a tree-like search if it does not check.

Third, we can compromise and check for cycles, but not for redundant paths in general.

3.3.4 Measuring problem-solving performance 

COMPLETENESS : Is the algorithm guaranteed to find a solution when there is one, and to correctly report failure when there is not?

COST OPTIMALITY : Does it find a solution with the lowest path cost of all solutions?

TIME COMPLEXITY : How long does it take to find a solution?

SPACE COMPLEXITY : How much memory is needed to perform the search?

To be complete, a search algorithm must be systematic in the way it explores an infinite state space, making sure it can eventually reach any state that is connected to the initial state.

In theoretical computer science, the typical measure of time and space complexity is the size of the state-space graph, \(|V|+|E|\) , where \(|V|\) is the number of vertices (state nodes) of the graph and \(|E|\) is the number of edges (distinct state/action pairs). For an implicit state space, complexity can be measured in terms of \(d\) , the depth or number of actions in an optimal solution; \(m\) , the maximum number of actions in any path; and \(b\) , the branching factor or number of successors of a node that need to be considered.

3.4 Uninformed Search Strategies 

3.4.1 breadth-first search .

When all actions have the same cost, an appropriate strategy is breadth-first search , in which the root node is expanded first, then all the successors of the root node are expanded next, then their successors, and so on.

Breadth-first search always finds a solution with a minimal number of actions, because when it is generating nodes at depth \(d\) , it has already generated all the nodes at depth \(d-1\) , so if one of them were a solution, it would have been found.

All the nodes remain in memory, so both time and space complexity are \(O(b^d)\) . The memory requirements are a bigger problem for breadth-first search than the execution time . In general, exponential-complexity search problems cannot be solved by uninformed search for any but the smallest instances .

3.4.2 Dijkstra’s algorithm or uniform-cost search 

When actions have different costs, an obvious choice is to use best-first search where the evaluation function is the cost of the path from the root to the current node. This is called Dijkstra’s algorithm by the theoretical computer science community, and uniform-cost search by the AI community.

The complexity of uniform-cost search is characterized in terms of \(C^*\) , the cost of the optimal solution, and \(\epsilon\) , a lower bound on the cost of each action, with \(\epsilon>0\) . Then the algorithm’s worst-case time and space complexity is \(O(b^{1+\lfloor C^*/\epsilon\rfloor})\) , which can be much greater than \(b^d\) .

When all action costs are equal, \(b^{1+\lfloor C^*/\epsilon\rfloor}\) is just \(b^{d+1}\) , and uniform-cost search is similar to breadth-first search.

3.4.3 Depth-first search and the problem of memory 

Depth-first search always expands the deepest node in the frontier first. It could be implemented as a call to \(Best\-First\-Search\) where the evaluation function \(f\) is the negative of the depth.

For problems where a tree-like search is feasible, depth-first search has much smaller needs for memory. A depth-first tree-like search takes time proportional to the number of states, and has memory complexity of only \(O(bm)\) , where \(b\) is the branching factor and \(m\) is the maximum depth of the tree.

A variant of depth-first search called backtracking search uses even less memory.

3.4.4 Depth-limited and iterative deepening search 

To keep depth-first search from wandering down an infinite path, we can use depth-limited search , a version of depth-first search in which we supply a depth limit, \(l\) , and treat all nodes at depth \(l\) as if they had no successors. The time complexity is \(O(b^l)\) and the space complexity is \(O(bl)\)

Iterative deepening search solves the problem of picking a good value for \(l\) by trying all values: first 0, then 1, then 2, and so on—until either a solution is found, or the depth- limited search returns the failure value rather than the cutoff value.

Its memory requirements are modest: \(O(bd)\) when there is a solution, or \(O(bm)\) on finite state spaces with no solution. The time complexity is \(O(bd)\) when there is a solution, or \(O(bm)\) when there is none.

In general, iterative deepening is the preferred uninformed search method when the search state space is larger than can fit in memory and the depth of the solution is not known .

3.4.5 Bidirectional search 

An alternative approach called bidirectional search simultaneously searches forward from the initial state and backwards from the goal state(s), hoping that the two searches will meet.

3.4.6 Comparing uninformed search algorithms 

3.5 Informed (Heuristic) Search Strategies 

An informed search strategy uses domain–specific hints about the location of goals to find colutions more efficiently than an uninformed strategy. The hints come in the form of a heuristic function , denoted \(h(n)\) :

\(h(n)\) = estimated cost of the cheapest path from the state at node \(n\) to a goal state.

3.5.1 Greedy best-first search 

Greedy best-first search is a form of best-first search that expands first the node with the lowest \(h(n)\) value—the node that appears to be closest to the goal—on the grounds that this is likely to lead to a solution quickly. So the evaluation function \(f(n)=h(n)\) .

AI Agents, Assemble(Part 1)! The Future of Problem-Solving with AutoGen

Getting to know ai agents: how they work, why they’re useful, and what they can do for you.

Anushka sonawane

You’ve probably heard people talk about agents in AI . At first, I found the whole “agent” concept a little abstract — like, are they secret agents from spy movies or what? 😄 Turns out, they’re actually a lot cooler and much more useful in everyday tasks!

In this post, I’ll walk you through what agents are, how they work, and why using multiple agents is such a game-changer. And I’ll sprinkle in a few of my own experiences to help you really get the idea!

So, what’s an AI Agent?

In AI, an agent is essentially a smart assistant that can perform specific tasks without needing constant guidance. Once given a job, the agent uses its abilities — whether that’s generating text, solving problems, or even writing code — to complete it. Agents are built to act autonomously , meaning they don’t require someone to watch over them as they work.

Imagine it like this:

You tell the agent what to do, and it handles the rest independently. It specializes in certain tasks, making it really good at specific jobs. It can communicate with other agents or people to share information or get help.

Let me take you back to a time when I was juggling a ton of work for a project. I needed someone to research, someone to summarize that research, and another person to pull all the data together into a report. It felt like I needed three versions of myself . That’s basically what agents do — they act independently to get things done for you. Think of them as little “you’s” running around, handling different tasks.

Fast vs. Slow Thinking: How AI Agents Make Decisions

Just like humans, AI agents have two modes of thinking: Fast Thinking and Slow Thinking . And trust me, understanding these modes will completely change how you see AI.

Fast Thinking (Fixed Workflows): This is your brain’s autopilot. When you’re asked a question you know the answer to — like your name or the color of the sky — you don’t even need to think. You just answer automatically. Similarly, imagine an AI that tracks your spending. You input your expenses, and it instantly organizes them into categories. It’s fast and efficient but limited to this specific task. Slow Thinking (Dynamic Workflows): Now, let’s talk about what happens when you’re faced with a tricky problem. Instead of answering right away, you take your time, analyzing the situation step by step. This is like an AI helping you plan a party. It checks your schedule, suggests dates, creates a guest list from your contacts, offers menu ideas, and even helps you order decorations. If you change your mind, it adjusts everything smoothly. It’s flexible and thoughtful, just like how we carefully solve complex problems.

In short, fast thinking is for repetitive, routine tasks, while slow thinking is for creative, adaptive problem-solving.

Why Use Multiple Agents?

Now that we’ve talked about how agents work together, let me introduce you to AutoGen . Think of AutoGen as the team leader for all these agents, making sure everyone knows what they need to do and when. AutoGen makes it easier for developers (like me and possibly you) to create, customize, and manage agents that can handle complex tasks.

I once had a project where I needed to write a lot of code, but I also had to juggle research and content creation. It felt overwhelming. But with AutoGen, I could have easily set up different agents: one for writing, one for checking the code, and another for reviewing the final product. AutoGen would make sure they’re all working in sync, communicating, and getting things done efficiently.

Here’s how AutoGen helps:

• Conversable Agents : These agents don’t just do their own thing — they talk to each other. They pass info back and forth like teammates on a group project.
• Customizable Abilities : You can tailor each agent to do specific tasks — one can be an expert writer, another might be a math genius, and a third can handle coding.
• Task Coordination : AutoGen makes sure all the agents are working together. It’s like having a conductor in an orchestra, ensuring that every instrument plays at the right time.

Types of Agents in AutoGen

You can mix and match different types of agents depending on what you need. Here’s a breakdown of the most common types:

1. LLM-Backed Agents:

These agents use Large Language Models, like GPT-4, to think, generate ideas, and write content. I think of them as my creative thinkers — they help with everything from generating text to even writing code.

2. Human-Backed Agents:

Sometimes, even the smartest AI can use a human touch. These agents ask for help from humans when needed. It’s like when you’re doing a project and you get stuck — you call in a friend to help. I’ve definitely had moments where AI gets me 90% of the way , but I still want to tweak things. These agents handle that.

3. Tool-Backed Agents:

These agents are like your technical experts . They use tools to execute code, make API calls, or search databases. I’ve had agents like these handle the coding side of things while I focus on the creative aspects.

How Do These Agents Collaborate?

Let me share a quick personal story. Not long ago, I worked on a project to build a custom app. Normally, this kind of project takes a lot of coordination, but with AutoGen, things felt surprisingly manageable.

• Agent A (LLM-backed) designed the app layout.
• Agent B (Tool-backed) wrote the code based on the design.
• Agent C (Human-backed) reviewed the code and made sure the app was user-friendly.

By the end, it felt like I had this awesome team working alongside me. Each agent did what it was best at, and the project came together faster than I expected.

Why Multi-Agent Systems Matter (And Why I Wish I Had Them Sooner!)

You might be wondering why I’m so excited about multi-agent systems. Here’s why they’re a big deal:

When I’m working solo, I can only handle one task at a time. But with agents working in parallel, everything moves faster. It’s like having multiple versions of me working on different things at the same time!

2. Specialization:

Instead of being a jack-of-all-trades, agents are specialized. One focuses on fact-checking, another on coding, and another on writing. It’s like having a group of experts.

3. Fewer Mistakes:

When agents check each other’s work, there are fewer chances for mistakes. Trust me, I’ve been that person double- and triple-checking my own work, and it’s exhausting. Having agents handle this makes life a lot easier!

Real-World Examples of LLM Agents

To wrap things up, let’s take a look at some real-world examples of LLM agents in action

VisualGPT : It’s like ChatGPT, but with the ability to see images! VisualGPT connects chat conversations with image models, so it can handle both words and pictures at the same time.

BabyAGI : An AI assistant that helps you manage your tasks. It can plan and organize your to-dos automatically to make life easier.

Hearth AI : Think of it as an AI-powered relationship manager. It helps you manage and maintain connections, making relationships smoother, whether personal or professional.

What’s Next: Exploring AutoGen in Part 2

Now that we’ve scratched the surface of what agents are and how they can work together, it’s time to dive deeper. In Part 2 , we’ll focus on AutoGen , the tool that makes managing these agents super smooth.

We’ll explore:

• How to set up and configure your own agents with AutoGen.
• Tips for customizing agents to tackle different tasks, whether it’s writing, coding, or anything else.
• How AutoGen can simplify complex workflows by coordinating multiple agents at once.

If you’re curious about how to actually use these agents in real-world projects, you won’t want to miss the next part. We’ll be taking a closer look at how AutoGen helps bring it all together. Stay tuned!

If you’d like to follow along with more insights or discuss any of these topics further, feel free to connect with me:

Looking forward to chatting and sharing more ideas!

Wait, There’s More! If you enjoyed this, you’ll love my other blogs! 🎯

Unlocking the MLOps Secrets: Expertly Navigating Deployment, Maintenance, and Scaling

Hey, tech explorers, protect your python projects: avoid direct setup.py invocation for ultimate code safeguarding, it’s time to say goodbye to setup.py complexities and embrace efficient python packaging with build frontends..

pub.towardsai.net

Enhancing RAG Efficiency through LlamaIndex Techniques

Llama index and rag basics with detailed explanation.

Until next time , Anushka!

Written by Anushka sonawane

Software Developer | Researcher | Machine Learning | Artificial Intelligence | Python

Text to speech

This week: the arXiv Accessibility Forum

Help | Advanced Search

Computer Science > Artificial Intelligence

Title: creative problem solving in artificially intelligent agents: a survey and framework.

Abstract: Creative Problem Solving (CPS) is a sub-area within Artificial Intelligence (AI) that focuses on methods for solving off-nominal, or anomalous problems in autonomous systems. Despite many advancements in planning and learning, resolving novel problems or adapting existing knowledge to a new context, especially in cases where the environment may change in unpredictable ways post deployment, remains a limiting factor in the safe and useful integration of intelligent systems. The emergence of increasingly autonomous systems dictates the necessity for AI agents to deal with environmental uncertainty through creativity. To stimulate further research in CPS, we present a definition and a framework of CPS, which we adopt to categorize existing AI methods in this field. Our framework consists of four main components of a CPS problem, namely, 1) problem formulation, 2) knowledge representation, 3) method of knowledge manipulation, and 4) method of evaluation. We conclude our survey with open research questions, and suggested directions for the future.

Submission history

Access paper:.

• Other Formats

References & Citations

• Google Scholar
• Semantic Scholar

BibTeX formatted citation

Bibliographic and Citation Tools

Code, data and media associated with this article, recommenders and search tools.

• Institution

arXivLabs: experimental projects with community collaborators

arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website.

Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them.

Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs .

Artificial Intelligence

• Artificial Intelligence (AI)
• Applications of AI
• History of AI
• Types of AI
• Intelligent Agent
• Types of Agents
• Agent Environment
• Turing Test in AI

Problem-solving

• Search Algorithms
• Uninformed Search Algorithm
• Informed Search Algorithms
• Hill Climbing Algorithm
• Means-Ends Analysis

Adversarial Search

• Adversarial search
• Minimax Algorithm
• Alpha-Beta Pruning

Knowledge Represent

• Knowledge Based Agent
• Knowledge Representation
• Knowledge Representation Techniques
• Propositional Logic
• Rules of Inference
• The Wumpus world
• knowledge-base for Wumpus World
• First-order logic
• Knowledge Engineering in FOL
• Inference in First-Order Logic
• Unification in FOL
• Resolution in FOL
• Forward Chaining and backward chaining
• Backward Chaining vs Forward Chaining
• Reasoning in AI
• Inductive vs. Deductive reasoning

Uncertain Knowledge R.

• Probabilistic Reasoning in AI
• Bayes theorem in AI
• Bayesian Belief Network
• Examples of AI
• AI in Healthcare
• Artificial Intelligence in Education
• Artificial Intelligence in Agriculture
• Engineering Applications of AI
• Advantages & Disadvantages of AI
• Robotics and AI
• Future of AI
• Languages used in AI
• Approaches to AI Learning
• Scope of AI
• Agents in AI
• Artificial Intelligence Jobs
• Amazon CloudFront
• Goals of Artificial Intelligence
• Can Artificial Intelligence replace Human Intelligence
• Importance of Artificial Intelligence
• Artificial Intelligence Stock in India
• How to Use Artificial Intelligence in Marketing
• Artificial Intelligence in Business
• Companies Working on Artificial Intelligence
• Artificial Intelligence Future Ideas
• Government Jobs in Artificial Intelligence in India
• What is the Role of Planning in Artificial Intelligence
• AI as a Service
• AI in Banking
• Cognitive AI
• Introduction of Seaborn
• Natural Language ToolKit (NLTK)
• Best books for ML
• AI companies of India will lead in 2022
• Constraint Satisfaction Problems in Artificial Intelligence
• How artificial intelligence will change the future
• Problem Solving Techniques in AI
• AI in Manufacturing Industry
• Artificial Intelligence in Automotive Industry
• Artificial Intelligence in Civil Engineering
• Artificial Intelligence in Gaming Industry
• Artificial Intelligence in HR
• Artificial Intelligence in Medicine
• PhD in Artificial Intelligence
• Activation Functions in Neural Networks
• Boston Housing Kaggle Challenge with Linear Regression
• What are OpenAI and ChatGPT
• Chatbot vs. Conversational AI
• Iterative Deepening A* Algorithm (IDA*)
• Iterative Deepening Search (IDS) or Iterative Deepening Depth First Search (IDDFS)
• Genetic Algorithm in Soft Computing
• AI and data privacy
• Future of Devops
• How Machine Learning is Used on Social Media Platforms in 2023
• Machine learning and climate change
• The Green Tech Revolution
• GoogleNet in AI
• AlexNet in Artificial Intelligence
• Basics of LiDAR - Light Detection and Ranging
• Explainable AI (XAI)
• Synthetic Image Generation
• What is Deepfake in Artificial Intelligence
• What is Generative AI: Introduction
• Artificial Intelligence in Power System Operation and Optimization
• Customer Segmentation with LLM
• Liquid Neural Networks in Artificial Intelligence
• Propositional Logic Inferences in Artificial Intelligence
• Text Generation using Gated Recurrent Unit Networks
• Viterbi Algorithm in NLP
• What are the benefits of Artificial Intelligence for devops
• AI Tech Stack
• Speech Recognition in Artificial Intelligence
• Types of AI Algorithms and How Do They Work
• AI Ethics (AI Code of Ethics)
• Pros and Cons of AI-Generated Content
• Top 10+ Jobs in AI and the Right Artificial Intelligence Skills You Need to Stand Out
• AIOps (artificial intelligence for IT operations)
• Artificial Intelligence In E-commerce
• How AI can Transform Industrial Safety
• How to Gradually Incorporate AI in Software Testing
• Generative AI
• NLTK WordNet
• What is Auto-GPT
• Artificial Super Intelligence (ASI)
• AI hallucination
• How to Learn AI from Scratch
• What is Dilated Convolution?
• Explainable Artificial Intelligence(XAI)
• AI Content Generator
• Artificial Intelligence Project Ideas for Beginners
• Beatoven.ai: Make Music AI
• Google Lumiere AI
• Handling Missing Data in Decision Tree Models
• Impacts of Artificial Intelligence in Everyday Life
• OpenAI DALL-E Editor Interface
• Water Jug Problem in AI
• What are the Ethical Problems in Artificial Intelligence
• Difference between Depth First Search, Breadth First Search, and Depth Limit Search in AI
• How To Humanize AI Text for Free
• 5 Algorithms that Demonstrate Artificial Intelligence Bias
• Artificial Intelligence - Boon or Bane
• Character AI
• 18 of the best large language models in 2024
• Explainable AI
• Conceptual Dependency in AI
• Problem characteristics in ai
• Top degree programs for studying artificial Intelligence
• AI Upscaling
• Artificial Intelligence combined with decentralized technologies
• Ambient Intelligence
• Federated Learning
• Neuromorphic Computing
• Bias Mitigation in AI
• Neural Architecture Search
• Top Artificial Intelligence Techniques
• Best First Search in Artificial Intelligence
• Top 10 Must-Read Books for Artificial Intelligence
• What are the Core Subjects in Artificial Intelligence
• Features of Artificial Intelligence
• Artificial Intelligence Engineer Salary in India
• Artificial Intelligence in Dentistry
• des.ai.gn - Augmenting Human Creativity with Artificial Intelligence
• Best Artificial Intelligence Courses in 2024
• Difference Between Data Science and Artificial Intelligence
• Narrow Artificial Intelligence
• What is OpenAI
• Best First Search Algorithm in Artificial Intelligence
• Decision Theory in Artificial Intelligence
• Subsets of AI
• Expert Systems
• Machine Learning Tutorial
• NLP Tutorial
• Artificial Intelligence MCQ

Related Tutorials

• Tensorflow Tutorial
• PyTorch Tutorial
• Data Science Tutorial
• Reinforcement Learning

Latest Courses

We provides tutorials and interview questions of all technology like java tutorial, android, java frameworks

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

[email protected] .

Interview Questions

Online compiler.

The Rise of Large Action Models Heralds the Next Wave of Autonomous AI

AI agents and assistants have the ability to take action on a user’s behalf, but each serves a distinct purpose.

Silvio Savarese

Share article.

Generative AI has officially entered its second act, driven by a new generation of AI agents capable of taking action just as deftly as they can hold a conversation. These autonomous AI systems can execute tasks, either in support or on behalf of humans through their ability to leverage external tools and access up-to-date information beyond their training data.

Like an LLM’s more sophisticated cousin, these agents are powered by Large Action Models — the latest in a string of innovations that inch us closer to an autonomous AI future. July saw the release of our small agentic models, xLAM-1B (“ Tiny Giant ”) alongside xLAM-7B.

xLAM is capable of carrying out complex tasks on behalf of its users, with benchmark testing showing that it verifiably outperforms much larger (and more expensive) models despite its remarkably small size. LAMs offer an early glimpse of a near future where AI-powered agents will extend what we’re capable of as individuals and supercharge the efficiency of organisations. How will this work in practice? 

At Salesforce, we believe autonomous enterprise AI will take two primary forms: AI assistants and AI agents . Both share two important traits. The first is agency , or the ability to act in meaningful ways, sometimes entirely on their own, in pursuit of an assigned goal. The second is the remarkable capability to learn and evolve over time, but in distinct ways. AI assistants will adapt in unique, individually tailored ways to better understand a single user – the human user they need to provide assistance for.

AI agents, on the other hand, will adapt to better support a team or organisation, learning best practices, shared processes and much more. Simply put, AI assistants are built to be personalised, while AI agents are built to be shared (and scaled). Both promise extraordinary opportunities for enterprises.

The power of learning over time

The notion of learning and improving through repetition is a fundamental aspect of autonomous AI, but crucial differences exist between different implementations. In the case of the AI assistant, learning is all about developing an efficient working relationship with the human it’s supporting.

Over time, the assistant will identify habits, expectations, and even working rhythms unique to an individual. Given the sensitive nature of this type of data, privacy and security are non-negotiables — after all, no one wants an assistant they can’t trust, no matter how good it is.

AI agents, on the other hand, are meant to learn shared practices like tools and team workflows. Far from being private, they’ll disseminate the information they learn to other AI agents throughout their organisation. This means that as each individual AI agent improves its performance through learning and field experience, every other agent of that type should make the same gains, immediately.

Both AI agents and assistants will also be able to learn from external sources through techniques such as retrieval augmented generation (RAG), and will automatically integrate new apps, features, or policy changes pushed across the enterprise. 

Driving real-world impact

Together, agents and assistants add up to nothing less than a revolution in the way we work, with use cases ranging from sales enablement to customer service, to full-on IT support. Imagine, for example, a packed schedule of sales meetings, ranging from video calls to in-person trips across the globe, stretching across the busiest month of the season.

It’s a hectic reality for sales professionals in just about every industry, but it’s made far more complex by the need to manually curate the growing treasure trove of CRM data generated along the way. But what if an AI assistant, tirelessly tagging along from one meeting to the next, automatically tracked relevant details and precisely organised them, with the ability to answer on-demand questions about all of it? How much easier would that schedule be? How much more alert and present would the salesperson be, knowing their sole responsibility was to focus on the conversation and the formation of a meaningful relationship?

What’s especially interesting is visualising how this all would work. Your AI assistant would be present during each meeting, following the conversation from one moment to the next, and developing an ever-deeper understanding of your needs, behaviour, and work habits — with an emphasis, of course, on privacy.

As your AI assistant recognises the need to accomplish specific tasks, from retrieving organisational information to looking up information on the internet or summarising meeting notes, it would delegate to an AI agent for higher level subtasks, or invoke an Action for single specific subtasks, like querying a knowledge article. It might look something like this:

It’s not hard to imagine how AI agents and assistants could benefit other departments as well, such as customer service. For even a small or medium-sized business, the number of support tickets a typical IT desk faces throughout the day can be staggering.

While human attention will always be required for solving complex and unusual challenges that demand the fullness of our ingenuity, the vast majority of day-to-day obstacles are far less complicated. AI agents can take on much of this work, seamlessly scaling up and down with demand to handle large volumes of inbound requests, freeing up overworked IT professionals to focus on tougher problems and reducing wait times for customers.

The challenges ahead

The road to this autonomous AI future won’t be easy, with technical, societal and even ethical challenges ahead. Chief among them is the question of persistence and memory. If we wish, AI assistants will know us well, from our long-term plans to our daily habits and quirks. Each new interaction should build on a foundation of previous experiences, just as we do with our friends and coworkers. 

But achieving this with current AI models isn’t trivial. Compute and storage costs, latency considerations, and even algorithmic limitations are all complicating factors in our efforts to build autonomous AI systems with rich, robust memory and attention to detail.

We also have much to learn from ourselves; consider the way we naturally “prune” unnecessary details from what we see and hear, retaining only those details we imagine will be most relevant in the future rather than attempting unreasonable feats of brute force memorisation. Whether it’s a meeting, a classroom lecture, or even a conversation with a friend, humans are remarkably good at compressing minutes, or even hours of information into a few key takeaways. AI assistants will need to have similar capabilities. 

Even more important than the depth of an AI’s memory is our ability to trust what comes out of it. For all its remarkable power, generative AI is still often hampered by questions of reliability and problems like “ hallucinations ”. Because hallucinations tend to stem from knowledge gaps, autonomous AI’s propensity for continued learning will play a role in helping address this issue, but more must be done along the way.

One measure is the burgeoning practice of assigning confidence scores to LLM outputs. Additionally, retrieval augmented generation (RAG) is one of a growing number of grounding techniques that allow AI users to augment their LLM prompts with relevant knowledge to ensure the model has the necessary context it needs to process a request.

Ethical considerations will be similarly complex. For instance, will the emergence of autonomous AI systems bring with them the need for entirely new protocols and norms? How should AI agents and teams talk to each other? How should they build consensus, resolve disputes and ambiguities, and develop confidence in a given course of action? How can we calibrate their tolerance for risk or their approach to conflicting goals like expenditures of time vs. money?

And regardless of what they value, how can we ensure that their decisions are transparent and easily scrutinised in the event of an outcome we don’t like? In short, what does accountability look like in a world of such sophisticated automation?

One thing is for sure — humans should always be the ones to determine how, when and why digital agents are deployed. Autonomous AI can be a powerful addition to just about any team, but only if the human members of that team are fully aware of its presence and the managers they already know and trust are fully in control .

Additionally, interactions with all forms of AI should be clearly labeled as such, with no attempt — well intentioned or otherwise — to blur the lines between human and machine. As important as it will be to formalise thoughtful protocols for communication between such agents, protocols for communication between AI and humans will be at least as important, if not more so.

As ambitious as our vision of an agent-powered future may seem, the release of xLAM-1B Tiny Giant and others in our suite of small agentic models, are strong evidence that we’re well on our way to achieving it. 

Much remains to be done, both in terms of technological implementation and the practices and guidance required to ensure AI’s impact is beneficial and equitable for all. But with so many clear benefits already emerging, it’s worthwhile to stop and smell the roses and appreciate just how profound this current chapter of AI history is proving itself to be. 

Are you ready for AI?

Take our free assessment today to see if your company is ready to take the next step with AI. You’ll receive customised recommendations, helping you effectively implement AI into your organisation.

Just For You

What Is a Customer Portal – And Why Do You Need One?

What’s the Revenue Impact of Using AI-Driven Marketing Strategies?

Explore related content by topic

• Digital Transformation
• Generative AI

Silvio Savarese is the Executive Vice President and Chief Scientist of Salesforce AI Research, as well as an Adjunct Faculty of Computer Science at Stanford University, where he served as an Associate Professor with tenure until winter 2021. At Salesforce, he shapes the scientific direction and ... Read More long-term AI strategy by aligning research and innovation efforts with Salesforce’s mission and objectives. He leads the AI Research organisation, including AI for C360 and CRM, AI for Trust, AI for developer productivity, and operational efficiency.

Get our bi-weekly newsletter for the latest business insights.

What is Generative CRM — And What Will It Mean for Your Business?

4 Ways Public Sector Uses Data To Deliver Personalised Experiences

How Will Generative AI Streamline Omnichannel Commerce?

How AI Innovation Can Boost Productivity and Sales for Your SME

AI Is No Longer for the Few — AI Is for Everyone

Your Industry Is Using AI To Improve Customer Service — Are You?

Five Reasons You Should Attend World Tour Essentials Johannesburg

AI From A to Z: The Generative AI Glossary for Business Leaders

New to Salesforce?

• What is Salesforce?
• What is CRM?
• What is Cloud Computing?
• CRM Solutions
• Customer Success Stories
• Product pricing

About Salesforce

• Security and Performance
• Privacy for Salesforce Products
• Salesforce EU Blog
• Salesforce EU Blog Signup

Popular Links

• Small Business CRM
• Sales Force Automation
• Customer Service Solutions
• Digital Marketing Solutions
• Industry Solutions
• Salesforce Events
• New Release Features
• Manage Subscription
• América Latina (Español)
• Brasil (Português)
• Canada (English)
• Canada (Français)
• United States (English)

Europe, Middle East, and Africa

• España (Español)
• Deutschland (Deutsch)
• France (Français)
• Italia (Italiano)
• Nederland (Nederlands)
• Sverige (Svenska)
• United Kingdom (English)
• All other countries (English)

Asia Pacific

• Australia (English)
• India (English)
• Malaysia (English)
• ประเทศไทย (ไทย)

© Copyright 2024 Salesforce, Inc. All rights reserved . Various trademarks held by their respective owners. Salesforce UK Limited, Village 9, Floor 26 Salesforce Tower, 110 Bishopsgate, London, UK, EC2N 4AY. Phone: +353 14403500. Fax: +353 14403501