diff --git a/pages/guides/agents/getting-started/create-a-uagent.mdx b/pages/guides/agents/getting-started/create-a-uagent.mdx
index 3b0609908..02542a94f 100644
--- a/pages/guides/agents/getting-started/create-a-uagent.mdx
+++ b/pages/guides/agents/getting-started/create-a-uagent.mdx
@@ -6,9 +6,9 @@ import { CodeGroup, CodeSegment, DocsCode, GithubCodeSegment } from "../../../..
 
 Once you've [installed ↗️](/guides/agents/installing-uagent) the uAgents library, it's quite simple to get a minimal use case running.
 
-The uAgents Framework streamlines agent creation by offering tools for communication, discovery, and publication within the Fetch.ai network. It empowers users and developers with flexibility, allowing them to build agents using anything from cutting-edge Large Language Models (LLMs) to simple APIs.
+The uAgents Framework simplifies Agents creation, and enables Agents communication, discovery, and publication on the Fetch.ai network. The Framework supports building Agents using anything from advanced Large Language Models (LLMs) to basic APIs.
 
-Let our first agent be a simple initialization and printing out the agent's name and address.
+Let's start with a simple Agent that initializes and prints its name and address
 
 ## Prerequisites
 
@@ -30,19 +30,19 @@ Make sure you have read the following resources before going on with this guide:
            ```py copy filename="mac"
            touch first_agent.py
            ```
-           </DocsCode>
+        </DocsCode>
 
        <DocsCode windows={true}>
            ```py copy filename="windows"
            echo. > first_agent.py
            ```
-           </DocsCode>
+        </DocsCode>
 
        <DocsCode ubuntu={true}>
            ```py copy filename="ubuntu"
            touch first_agent.py
            ```
-           </DocsCode>
+       </DocsCode>
    </CodeGroup>
 
 2. We then need to import the `Agent` and `Context` classes from the `uagents` library, and then create an agent using the class `Agent`:
diff --git a/pages/guides/agents/getting-started/whats-an-agent.mdx b/pages/guides/agents/getting-started/whats-an-agent.mdx
index a21d05c1e..34bf861f5 100644
--- a/pages/guides/agents/getting-started/whats-an-agent.mdx
+++ b/pages/guides/agents/getting-started/whats-an-agent.mdx
@@ -24,11 +24,11 @@ The **uAgents Framework** is a lightweight library designed to facilitate the de
   alt="agents-interacting"
 />
 
-Agents are autonomous software program built using the uAgents framework and that can interact autonomously with other agents in a decentralized environment. These agents can operate in a decentralized manner, but their decentralization remains optional and dependent on individual preferences or needs.
+Agents, built with the uAgents Framework, are autonomous software programs capable of interacting with others in a decentralized environment. While decentralization is supported, it remains optional based on user needs.
 
-Intelligent agents can fundamentally change the way we see complicated systems. For example, supply chain management could deploy Agents using the uAgents Framework to improve operations at various stages. Demand forecasting, inventory control, logistics optimization, supplier relationships monitoring, quality control and risk mitigation in all areas can be done with their help. Agents could transform supply chain operations by increasing efficiency, reducing costs, improving accuracy and providing real-time visibility.
+Intelligent Agents can revolutionize complex systems. For instance, in supply chain management, Agents can enhance demand forecasting, inventory control, logistics optimization, supplier monitoring, quality control, and risk mitigation. This leads to improved efficiency, cost reduction, accuracy, and real-time visibility.
 
-These agents are the basic building blocks that allow developers to gain access to the tools and resources provided by the uAgents Framework, enabling them to create and participate in intelligent and self-managed systems that can be used in various real-world domains.
+These Agents are the foundation for developers to leverage the uAgents Framework, enabling the creation of intelligent, self-managed systems across various domains.
 
 <ImageByTheme
   darkSrc={DarkDecentralisedNetwork}
@@ -38,13 +38,13 @@ These agents are the basic building blocks that allow developers to gain access
 
 ## Why Agents
 
-With the rise of Large Language Models (LLMs) and AI-related products, autonomous intelligent agents have become the link between these models and tools. They are revolutionizing the way we solve problems, make decisions and collaborate with each other.
+With the rise of Large Language Models (LLMs) and AI-driven products, autonomous Agents bridge the gap between these tools, transforming how we solve problems, make decisions, and collaborate.
 
-The financial industry is another example. In this scenario, the automation of trading transactions, risk assessment, fraud detection and customer support would be greatly aided by Agents. They can use predictive analytics to perform real-time market trend analysis, perform risk assessments for loans and investments, and create customized financial advice for clients based on their profiles and the state of the market. By continuously monitoring transactions and patterns, they could also help to detect fraud, strengthening security measures. Agents in the financial sector have the potential to simplify processes, provide insightful information and improve decision-making for both financial companies and individual investors.
+For instance, within the financial sector, Agents can automate trading, risk assessment, fraud detection, and customer support operations. By leveraging predictive analytics, they can analyze market trends, assess risks for loans and investments, and potentially offer tailored financial advice. Agents can also enhance security by detecting fraud through continuous transaction monitoring. This simplifies processes, provides valuable insights, and supports better decision-making for both financial institutions and investors.
 
-In this context, Fetch.ai introduces the **uAgents Framework**. Using this open-source framework, developers are able to create intelligent, autonomous agents and join a decentralized network of many agents to effectively tackle the challenges of the modern world. Agents only perform tasks specified by the developers, and these tasks can be precisely described by coding customizable behavior for specific use cases and scenarios.
+Fetch.ai's uAgents Framework empowers developers to create Agents that can join a decentralized network to tackle real-world challenges. Developers can customize Agents behavior to perform precise tasks tailored to specific use cases.
 
-The concept of agents refers to autonomous, decentralized systems that overcome conventional limitations. Agents provide a gateway to a future where intelligent agents, empowered by the Fetch network and the [AI Engine ↗️](/concepts/ai-engine/ai-engine-intro), can communicate, negotiate and collaborate to streamline complex tasks, solve complicated problems and improve decision-making processes in various fields.
+The concept of Agents refers to autonomous, decentralized systems that overcome conventional limitations. Agents provide a gateway to a future where intelligent Agents, empowered by the Fetch network and the [AI Engine ↗️](/concepts/ai-engine/ai-engine-intro), can communicate, negotiate and collaborate to streamline complex tasks, solve complex problems and improve decision-making processes in various fields.
 
 ### Get started with Agents development!
 
diff --git a/pages/guides/agents/intermediate/agent-types.mdx b/pages/guides/agents/intermediate/agent-types.mdx
index 0c0c445ac..268d85f69 100644
--- a/pages/guides/agents/intermediate/agent-types.mdx
+++ b/pages/guides/agents/intermediate/agent-types.mdx
@@ -2,19 +2,15 @@ import { CodeGroup, CodeSegment, DocsCode, GithubCodeSegment } from "../../../..
 
 # Hosted, Local, and Mailbox Agents
 
-Agents can operate in multiple environments based on how they are created and deployed within the network. Understanding the difference between **Hosted**, **Local**, and **Mailbox Agents** is helpful for developers to correctly choose the right setup for their use cases and applications.
+Agents operate in various environments depending on how they are created and deployed. 
 
-## Hosted Agents
-
-[Hosted Agents ↗️](/guides/agentverse/creating-agentverse-agents/creating-a-hosted-agent) are cloud-based agents managed within the [Agentverse ↗️](https://agentverse.ai/). This allows developers to build, deploy, and run Agents without worrying about infrastructure management. The Agentverse ensures that your agents run as functions, executing routines and handling messages straightforwardly in response to specific triggers. This design keeps the operational costs of hosted agents low, which is passed on to the users.
+Understanding the difference between **Hosted**, **Local**, and **Mailbox Agents** helps developers choose the right setup for their needs.
 
-Agentverse provides a variety of tools to make agent development easy. First of all, the Agent Editor which allows you to write, edit, and manage your agents directly in the Agentverse environment. It includes essential features such as the Agent Logs, where you can view real-time outputs of your agent's execution, helping you monitor and debug your agents on the fly. The platform also offers storage and secrets management, enabling you to securely manage data and information. One important feature of hosted agents is _how they manage their state_. Since hosted agents do not run continuously, any global variable you define will always revert to its initialized value after each function call. For example, if you try to increment a global counter, its value will reset to the starting value every time the function is invoked. To persist data between calls, you must use the Agent Storage; this ensures key values are maintained across function executions. This is crucial for developing agents that require stateful behavior over time. .
-
-When creating hosted agents, you can either start from a blank script or use one of the many predefined templates available. These templates cover a range of use cases, such as smart services or AI/ML integrations, allowing developers to quickly get started with agents designed to toss a coin, retrieve stock prices, or find nearby restaurants. The template system simplifies agent creation by providing a foundation, while also allowing for customization to meet specific requirements following the idea users have in mind.
+## Hosted Agents
 
-A key advantage of hosted agents is that they do not require local dependencies, making development more accessible. The system provides an integrated `agent.py` file, and although hosted agents can be created based on a restricted set of imports, they still offer significant flexibility for developers to create complex solutions.
+[Hosted Agents ↗️](/guides/agentverse/creating-agentverse-agents/creating-a-hosted-agent) are cloud-based Agents managed within the [Agentverse ↗️](https://agentverse.ai/),enabling developers to deploy and manage Agents without handling infrastructure. These Agents function as lightweight, efficient tasks, resetting global variables after each call. To maintain state across calls, developers must use Agent Storage for stateful behavior.
 
-For a better reference to these topics, check out the following resources:
+Developers can start with blank scripts or use customizable templates for common use cases like retrieving stock prices or finding nearby restaurants. Hosted Agents are highly accessible, requiring no local dependencies, and include an `agent.py` file from which you can develop them straightforwardly. For a better reference to these topics, check out the following resources:
 
     - [Creating Hosted Agents ↗️](/guides/agentverse/creating-agentverse-agents/creating-a-hosted-agent).
     - [Agentverse: Allowed Imports ↗️](/guides/agentverse/creating-agentverse-agents/allowed-imports).
@@ -22,17 +18,11 @@ For a better reference to these topics, check out the following resources:
 
 ## Local Agents
 
-Local agents instead run directly on your machine or infrastructure; this gives you full control over environment, configuration, and execution. Unlike Agentverse hosted agents, local agents can continuously run processes that handle events, messages, and tasks in real-time without relying on an orchestrator. This setup allows for enhanced flexibility and dynamic behavior, as agents can manage their state across function calls without needing to store data externally. This feature makes them ideal for use cases where real-time processing and direct access to local resources are critical.
-
-When developing local agents, you can leverage the entire uAgents Framework, which offers a wide range of tools to support agent-based development. Also, since local agents do not face the same constraints as hosted agents, you are free to use any Python package or custom module that fits your project; this increases flexibility in design, and enables the use of powerful libraries for machine learning, data processing, and external integrations that may not be supported on Agentverse.
-
-A key benefit of local agents is their ability to maintain persistent state without external storage. Since they run continuously, global variables and internal states are maintained across multiple function executions. For instance, if you have a counter that increments every time a message is received, it will correctly retain its value throughout the agent's lifecycle. This contrasts with hosted agents, where global variables are re-initialized with each call and require storage to persist data.
-
-Running a local agent involves setting up a Python environment on your machine, installing the necessary dependencies, and executing the agent script. Agents can run indefinitely, waiting for incoming messages or scheduled tasks, which makes them well-suited for applications that require constant monitoring, immediate response handling, or interactions with other agents in real-time.
+Local Agents run on your machine or infrastructure, providing complete control over their environment, configuration, and execution. Unlike hosted Agents, they handle real-time events, messages, and tasks continuously, making them ideal for persistent state and direct access to local resources.
 
-A local agent can also be run within a Docker container, making it easier to deploy agents in a production environment or across distributed systems. This is particularly useful when building functions that need to scale across multiple systems or require isolation from other processes.
+Using the uAgents Framework, Local Agents integrate with any Python package or custom module, supporting advanced capabilities like machine learning and data processing. They maintain persistent state across function executions, unlike hosted Agents, where state resets after each call. Setting up a Local Agent requires a Python environment, dependencies, and running the Agent script. They can operate continuously or within Docker containers for scalability and isolation.
 
-Local agents allow for deeper customization and optimization features; you can manage resource allocation, tune performance settings, and integrate directly with other services running on the same machine. This makes local agents the preferred choice for high-performance applications or scenarios where you need to closely manage system resources and agent behavior.
+Local Agents are perfect for high-performance, real-time applications requiring deep customization, resource management, and seamless integration with local services.
 
 Head over to the following resource for a better understanding of Agents and their applications:
 
@@ -43,11 +33,11 @@ Head over to the following resource for a better understanding of Agents and the
 
 ## Mailbox Agents
 
-The [Agentverse Mailbox feature ↗️](/guides/agents/intermediate/mailbox) makes agents a hybrid between Hosted and Local Agents. This because Local Agents may not always be online all the time due to network outages, being behind a firewall, or intentionally going offline for resource management. It may also be that you need to create an Agent application using imports and tools that are currently not available in the Agentverse, and thus you need to design agents locally to guarantee fully operative and runnable application.  To manage such scenarios, the **Mailbox** feature in Agentverse allows agents to receive messages while they are offline with ease. Once the agent comes back online, it can retrieve these messages from its mailbox.
+The [Agentverse Mailbox feature ↗️](/guides/agents/intermediate/mailbox) makes Agents a hybrid between Hosted and Local types. This because Local Agents may not always be online all the time due to network outages, being behind a firewall, or intentionally going offline for resource management. To manage such scenarios, the **Mailbox** feature in Agentverse allows Agents to receive messages while they are offline with ease. Once the Agent comes back online, it can retrieve these messages from its mailbox.
 
-Local agents can use a Mailbox to ensure that no messages are lost when they are temporarily disconnected from the network; the Mailbox acts as a message buffer, storing communications until the agent comes back online and ready to process them. Indeed, this feature enables interaction with other agents or functions without the agent being online continuously.
+**Local Agents can use a Mailbox to ensure that no messages are lost when they are temporarily disconnected from the network**; the Mailbox acts as a message buffer, storing communications until the Agent comes back online and ready to process them. Indeed, this feature enables interaction with other Agents or functions without the Agent being online continuously.
 
-In order to set up a mailbox for a local agent, you first need to create and configure a local agent. The agent's address is used to register it on the Agentverse, and then to generate a **Mailbox API key** for your agent. For instance, consider the following basic agent:
+In order to set up a mailbox for a local Agent, you first need to create and configure a local Agent. The Agent's address is used to register it on the Agentverse, and then to generate a **Mailbox API key** for your Agent. For instance, consider the following basic Agent:
 
 <GithubCodeSegment digest="67d527d8ecb6cc3ea76fdce279b2a78a">
     <CodeSegment
@@ -92,6 +82,6 @@ In order to set up a mailbox for a local agent, you first need to create and con
 
 
 
-Then, head over to the [Agentverse ↗️](https://agentverse.ai/) and navigate to the **My Agents** tab. Here, select **Local Agents** and click on **Connect Local Agent**. Paste your agent's address retrieved from running your local agent and follow the steps until you get a **Mailbox API Key**, which you will use to update your agent's configuration above. To test your Mailbox setup, you can create another agent (on Agentverse for instance) that sends messages to the Mailbox while the first agent is offline. When the first agent comes back online, it will retrieve and process the stored messages. For a complete example, check out this [guide ↗️](/guides/agentverse/agentverse-mailbox/utilising-the-mailbox).
+Then, head over to the [Agentverse ↗️](https://agentverse.ai/) and navigate to the **My Agents** tab. Here, select **Local Agents** and click on **Connect Local Agent**. Paste your Agent's address retrieved from running your local Agent and follow the steps until you get a **Mailbox API Key**, which you will use to update your Agent's configuration above. To test your Mailbox setup, you can create another Agent (on Agentverse for instance) that sends messages to the Mailbox while the first Agent is offline. When the first agent comes back online, it will retrieve and process the stored messages. For a complete example, check out this [guide ↗️](/guides/agentverse/agentverse-mailbox/utilising-the-mailbox).
 
-For a more complex example of an agent using a Mailbox, check out the following [guide ↗️](/guides/agents/intermediate/langchain-rag-agent).
+For a more complex example of an Agent using a Mailbox, check out the following [guide ↗️](/guides/agents/intermediate/langchain-rag-agent).
diff --git a/pages/guides/agents/intermediate/bureau.mdx b/pages/guides/agents/intermediate/bureau.mdx
index 3c27ca2d0..cda570222 100644
--- a/pages/guides/agents/intermediate/bureau.mdx
+++ b/pages/guides/agents/intermediate/bureau.mdx
@@ -22,9 +22,9 @@ Make sure you have read the following resources before going on with this guide:
 
     - [uAgents ↗️](https://pypi.org/project/uagents/)
 
-## Bureau Walkthrough
+## Walk-through
 
-This walkthrough will guide you through the process of setting up and running agents using the Bureau, demonstrating its key functionalities, including agent management, message handling, and external communication via endpoints.
+This walk-through will guide you through the process of setting up and running agents using the Bureau, demonstrating its key functionalities, including agent management, message handling, and external communication via endpoints.
 
 ### Step 1: Setting Up Agents
 
diff --git a/pages/guides/agents/intermediate/local-agent-inspector.mdx b/pages/guides/agents/intermediate/local-agent-inspector.mdx
index 1f1c5e263..512092972 100644
--- a/pages/guides/agents/intermediate/local-agent-inspector.mdx
+++ b/pages/guides/agents/intermediate/local-agent-inspector.mdx
@@ -3,28 +3,27 @@ import { CodeGroup, CodeSegment, DocsCode, GithubCodeSegment } from "../../../..
 
 # Local Agent Inspector
 
-The **Local Agent Inspector** is a developer tool on Agentverse that enhances the debugging and monitoring experience for [Agents running on a local infrastructure ↗️](/guides/agents/intermediate/agent-types#local-agents). It allows you to track and understand the real-time behavior of these Agents, whether they are connected to Agentverse or not. The tool offers developers detailed insights into your local agent's performance and interactions, even though the agent itself is run within your infrastructure.
+The Local Agent Inspector is a developer tool on Agentverse designed to streamline debugging and monitoring for [Agents running on a local infrastructure ↗️](/guides/agents/intermediate/agent-types#local-agents). It helps developers track real-time Agents behavior, whether connected to Agentverse or not, offering detailed insights into performance and interactions.
 
     <Callout type="info" emoji="ℹ️">
-        Local Agents can communicate and interact with other Agents and Functions connected to the Agentverse and Fetch Network through a Mailbox. For more information on Mailbox and how to connect local Agents and their function to the Agentverse, have a look at these guides:
+        Local Agents can communicate and interact with other Agents and Functions connected to the Agentverse and Fetch Network through a Mailbox. For more information on Mailbox and how to connect local Agents and their Functions to the Agentverse, have a look at these guides:
 
             - [Agent Mailbox ↗️](/guides/agents/intermediate/mailbox).  
+            - [Hosted, Local, and Mailbox Agents ↗️](/guides/agents/intermediate/agent-types).     
             - [Options for running local Agents ↗️](/guides/agents/intermediate/options-for-running-local-agents)
             - [Agent Functions ↗️](/guides/agents/intermediate/agent-functions). 
             - [Agentverse Functions: register your Agents Functions on the Agentverse! ↗️](/guides/agentverse/agentverse-functions/registering-agent-services). 
     </Callout>
 
-The **Local Agent Inspector** provides developers with key insights into their Agents, such as the Agent's address, local and external endpoints, message types, and detailed sender-recipient data. By visualizing detailed insights into your local agent's performance and interactions, the Inspector allows you to oversee how your Agent interacts with others, making it easier to optimize communication and troubleshoot complex, real-time tasks. This is particularly useful for Agents that handle local processing or resource management while interacting with other agents or systems.
+Developers can view key details such as the local Agent's address, endpoints, message types, and sender-recipient data. This visualization simplifies communication optimization and troubleshooting for Agents handling local processing or resource management.
 
-All message data is presented in a list, with the option to access the payload of each message. For those managing multiple agents, the Inspector provides a complete list of all running Agents. While support for agents managed through a **Bureau** is coming soon, this will eventually offer a full view of all local Agents alongside relevant details.
-
-In the future, the Inspector will allow direct connections between local Agents and Agentverse, enhancing the ease of managing and monitoring Agent interactions.
+The Inspector displays message data in a list, with options to view payloads, and provides an overview of all running Agents. Future updates will include support for Bureau-managed Agents and direct connections to Agentverse, further enhancing management and monitoring capabilities.
 
 ## How to access the Local Agent Inspector
 
 You can access the Local Agent Inspector by first coding and defining your Agent. 
 
-For instance, consider the following simple local agent:
+For instance, consider the following simple local Agent:
 
 <GithubCodeSegment digest="36661e2d104e8d5150bdb124abcbb17c">
     <CodeSegment
@@ -69,7 +68,7 @@ For instance, consider the following simple local agent:
 
 </CodeGroup>
 
-Once you successfully run your local agent and register it into the Almanac (**Make sure your Agent has enough funds to do so!**), you will be able to access the Inspector via the terminal log, which provides a dedicated link to the Inspector page. 
+Once you successfully run your local Agent and register it into the Almanac (**Make sure your Agent has enough funds to do so!**), you will be able to access the Inspector via the terminal log, which provides a dedicated link to the Inspector page. 
 
 By running the above Agent, the output you get should be similar to the following:
 
diff --git a/pages/guides/agents/intermediate/options-for-running-local-agents.mdx b/pages/guides/agents/intermediate/options-for-running-local-agents.mdx
index a83a306cb..541a97995 100644
--- a/pages/guides/agents/intermediate/options-for-running-local-agents.mdx
+++ b/pages/guides/agents/intermediate/options-for-running-local-agents.mdx
@@ -8,7 +8,7 @@ import { CodeGroup, CodeSegment, DocsCode, GithubCodeSegment } from "../../../..
 
 In some scenarios, you may want to run an agent on your own hardware or infrastructure; luckily this is very easy to do on any system that support **Python 3.10**.
 
-This system is pretty simple, as to get you started as quickly as possible. We're going to run this agent on any device you'd like, in this scenario we're running on a VM but you could run this on your laptop, raspberry pi or tweak for Agentverse. On startup our script will register our agent to the [Almanac ↗️](/references/contracts/uagents-almanac/almanac-overview), and then our agent will be available to communicate with other agents.
+This system is pretty simple, as to get you started as quickly as possible. We're going to run this agent on any device you'd like, in this scenario we're running on a VM, but you could run this on your laptop, raspberry pi or tweak for Agentverse. On startup our script will register our agent to the [Almanac ↗️](/references/contracts/uagents-almanac/almanac-overview), and then our agent will be available to communicate with other agents.
 
 ## Prerequisites
 
diff --git a/pages/guides/agents/intermediate/public-private-agents.mdx b/pages/guides/agents/intermediate/public-private-agents.mdx
index bc12e7b39..0fe8548c8 100644
--- a/pages/guides/agents/intermediate/public-private-agents.mdx
+++ b/pages/guides/agents/intermediate/public-private-agents.mdx
@@ -7,7 +7,7 @@ import DarkPublicAndPrivateAgents from 'src/images/concepts/ai-agents/dark_publi
 
 ## Introduction
 
-Transparency is a fundamental principle in decentralized finance (DeFi) and blockchain systems. Within the Fetch.ai network, **users have the ability to determine the amount of information they wish to publish**. This is thanks to the ability for users to create Agents as either **public** or **private**, based on their **introspectivity** and **protocol exposure** through the [Agentverse ↗️](/concepts/agent-services/agentverse-intro) platform.
+Transparency is a fundamental principle in Decentralized Finance (DeFi) and blockchain systems. Within the Fetch.ai network, **users have the ability to determine the amount of information they wish to publish**. This is thanks to the ability for users to create Agents as either **public** or **private**, based on their **introspectivity** and **protocol exposure** through the [Agentverse ↗️](/concepts/agent-services/agentverse-intro).
 
 <ImageByTheme
   darkSrc={DarkPublicAndPrivateAgents}
@@ -19,7 +19,7 @@ This allows users to provide greater flexibility to Agents, creating a balance b
 
 ## Defining public and private agents
 
-There are two ways in which an agent can be classified as public, they define an endpoint and or, they publish their manifests:
+There are two ways in which an Agent can be classified as public: they define an endpoint and/or, they publish their manifests:
 
         ```python
 
@@ -33,7 +33,7 @@ There are two ways in which an agent can be classified as public, they define an
 
         ```
 
-Private agents can be private in two ways, by hiding a protocol they use from public, and or not defining an endpoint:
+Private Agents can be private in two ways: by hiding a protocol they use from public and/or by not defining an endpoint:
 
         ```python
 
@@ -46,5 +46,5 @@ Private agents can be private in two ways, by hiding a protocol they use from pu
 
         ```
 
-You would need to share the ip of the private agent you're running to other agent you're communicating with.
+You would need to share the IP of the private Agent you're running to the other Agent you're communicating with.