diff --git a/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/_index.md b/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/_index.md
index 65c60bac5ef..e645ec8d1e7 100644
--- a/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/_index.md
+++ b/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/_index.md
@@ -50,7 +50,10 @@ To help you get started, the following sections list the available GenAI compone
| [GenAI Showcase App](https://marketplace.mendix.com/link/component/220475) | Understand what you can build with generative AI. Understand how to implement the Mendix Cloud GenAI, OpenAI, and Amazon Bedrock connectors and how to integrate them with the Conversational UI module. |Showcase App | 10.21 |
| [RFP Assistant Starter App / Questionnaire Assistant Starter App](https://marketplace.mendix.com/link/component/235917) | The RFP Assistant Starter App and the Questionnaire Assistant Starter App leverage historical RFPs (or question-answer pairs) and a continuously updated knowledge base to generate and assist in editing responses to RFPs, offering a time-saving alternative to manually finding similar responses and enhancing the knowledge management process. | Starter App | 10.21 |
| [Support Assistant Starter App](https://marketplace.mendix.com/link/component/231035) | Learn how to combine common GenAI patterns, such as function calling and RAG to build your support assistant. Connect it to a model like Anthropic Claude via Mendix Cloud GenAI or Amazon Bedrock or use an (Azure) OpenAI subscription. | Starter App | 10.21 |
+| [Agent Builder Starter App](https://marketplace.mendix.com/link/component/240369) | See an example of how to build an agentic mendix application. Use the Agent Builder from Agent Commons to build your support assistant. | Starter App | 10.21 |
| [GenAI Commons](/appstore/modules/genai/commons/) | Common capabilities that allow all GenAI connectors to be integrated with the other modules. You can also implement your own connector based on this. | Common Module | 10.21 |
+| [Agent Commons](/appstore/modules/genai/genai-for-mx/agent-commons/) | Build agentic functionality using common patterns in your application by defining, testing, and evaluating agents at runtime. | Common Module | 10.21 |
+| [MCP Server](https://marketplace.mendix.com/link/component/240380) | Make your Mendix business logic available to any agent in your enterprise landscape with the Mendix MCP Server module. Expose reusable prompts including the ability to use prompt parameters. List and run actions implemented in the application as tool. | Common Module | 10.21 |
| [Conversational UI](/appstore/modules/genai/conversational-ui/) | Create a Conversational UI, manage prompts or monitor token consumption in your app. | UI Module | 10.21 |
| [Mendix Cloud GenAI Connector](/appstore/modules/genai/mx-cloud-genai/MxGenAI-connector/) | Connect to Mendix Cloud and utilize Mendix Cloud GenAI resource packs directly within your Mendix application. | Connector Module | 10.21 |
| [OpenAI Connector](/appstore/modules/genai/openai/) | Connect to (Azure) OpenAI. | Connector Module | 10.21 |
diff --git a/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/concepts/agents.md b/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/concepts/agents.md
new file mode 100644
index 00000000000..4fb3bebf4a8
--- /dev/null
+++ b/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/concepts/agents.md
@@ -0,0 +1,70 @@
+---
+title: "GenAI Agents"
+url: /appstore/modules/genai/agents/
+linktitle: "GenAI Agents"
+weight: 40
+description: "Describes Agents and Agentic Patterns as used with generative AI in Mendix"
+---
+
+## Introduction
+
+GenAI agents are autonomous computational systems that perform actions in response to triggers such as user input or system events. These agents apply reasoning, execute tools (functions), and leverage data from knowledge bases to determine the most appropriate responses. They may be adaptive (learning-based) or task-specific, designed to automate processes and improve operational efficiency.
+
+If you are interested in creating your own agent, explore the guide on [building your first agent in Mendix](/appstore/modules/genai/how-to/howto-single-agent/). It walks you through how to combine prompt engineering, function calling, and knowledge base integration—all within a Mendix app.
+
+## Multi-Agent systems
+
+Sometimes, a single agent is not enough for more complex use cases. In such cases, a multi-agent solution is needed. Multi-agent architectures go beyond single-agent implementations when tasks become too complex for one agent to handle alone. While single agents work well for simple, well-defined tasks, more complex or uncertain scenarios require multiple agents to collaborate. Multi-agent systems enable the coordination of business processes, specialized task allocation, and protocol execution by invoking dedicated sub-agents, often dynamically. This approach leads to better performance and more efficient operations compared to relying on a single agent to handle everything.
+
+## Pattern Overview
+
+When building agents, choose a pattern that aligns with your system's goals. Ensure that task allocation and coordination work as intended and lead to the desired outcomes. You will find examples of common patterns below. For practical implementations, check out the GenAI Showcase App.
+
+### Prompt Chaining
+
+This approach uses a linear chain of multiple LLM calls, where the output of one call becomes the input for the next. The output can be passed directly or included in the next prompt with additional instructions. Each LLM call has its own system prompt and represents a distinct step in a larger process with an overarching goal. You do not need to use the same model for every step. The model can be selected based on the task of each LLM step.
+
+The system takes a user prompt as input, either typed directly or generated using prompt engineering techniques. Its output is typically the plain response from the final LLM call in the chain.
+
+ {{< figure src="/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining.svg" >}}
+
+### Prompt Chaining with Gatekeeper
+
+This is an extension of the linear chain of multiple LLM calls. Now, the gatekeeper LLM call is part of the linear flow. Unlike other steps, the gatekeeper does not always pass its output directly to the next call. Its role is to assess the input and decide whether to continue the flow or break out, typically in "unhappy" or exception scenarios. If the gatekeeper determines that the process should proceed, the next LLM call receives the same input that the gatekeeper received.
+
+As with the previous pattern, the system takes a user prompt as input, either entered directly or generated through prompt engineering techniques. The output is typically the plain result of the final LLM call in the happy flow. In an unhappy scenario, developers can choose to return either the gatekeeper agent’s response or a predefined static message.
+
+ {{< figure src="/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining-Gatekeeper.svg" >}}
+
+### Evaluator-Optimizer
+
+In the evaluator-optimizer workflow, one LLM generates a text, and another evaluates it by providing feedback. This loop continues until the output meets the evaluation criteria or reaches a maximum number of attempts.
+
+Alternative names for this pattern are:
+
+* LLM-as-a-judge (also used in testing or evaluation frameworks, so context is important to avoid confusion)
+* Generator evaluator
+
+The input of this system is a user prompt, either typed directly by the user or constructed using prompt engineering techniques. The output of the system is the plain output of the last iteration of the Generator Agent LLM call, as approved by the Evaluator Agent.
+
+ {{< figure src="/attachments/appstore/platform-supported-content/modules/genai/agents/Evaluator-optimizer.svg" >}}
+
+### Routing
+
+This pattern is especially effective when the system needs to handle a variety of specific tasks. For each task, a dedicated agent is created with a clear focus on its assigned responsibility. When the system is triggered, a router agent classifies the input and determines which supported task most closely matches the user's intent. Once a match is found, the original input (which may include chat history) is passed to the appropriate agent. This process is often referred to as “hand-off”. It transfers full responsibility to the selected agent, which processes the input and generates an output, typically without any awareness of the router's involvement.
+
+The system takes a user prompt as input, either entered directly or crafted using prompt engineering techniques. The output is typically the plain response from the agent chosen by the Router Agent. In some variations, the Router Agent may choose not to hand off the input if it determines that the request falls outside the system's supported scope. In such cases, the system returns either the Router Agent's own response or a static message explaining why the request could not be processed.
+
+ {{< figure src="/attachments/appstore/platform-supported-content/modules/genai/agents/Routing.svg" >}}
+
+## Learn More
+
+### Agent Builder
+
+Start from the [Agent Builder Starter App](https://marketplace.mendix.com/link/component/240369) from the Marketplace or add the [Agent Commons module](https://marketplace.mendix.com/link/component/240371) to your existing app and get started with agents and agentic patterns in Mendix.
+
+Read more about [Agent Commons](/appstore/modules/genai/genai-for-mx/agent-commons/) in the GenAI reference guide.
+
+### Additional Information
+
+ Read the blog post on [Multi-agent systems in a Mendix app](https://www.mendix.com/blog/how-multi-agent-ai-systems-in-mendix-can-train-you-for-a-marathon/)
\ No newline at end of file
diff --git a/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/reference-guide/agent-commons.md b/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/reference-guide/agent-commons.md
new file mode 100644
index 00000000000..39c1ef7e176
--- /dev/null
+++ b/content/en/docs/appstore/use-content/platform-supported-content/modules/genai/reference-guide/agent-commons.md
@@ -0,0 +1,214 @@
+---
+title: "Agent Commons"
+url: /appstore/modules/genai/genai-for-mx/agent-commons/
+linktitle: "Agent Commons"
+description: "Describes the purpose, configuration, and usage of the Agents Commons module from the Mendix Marketplace that allows developers to build, define, and refine Agents, to integrate GenAI principles, and Agentic patterns into their Mendix app."
+weight: 20
+---
+
+## Introduction
+
+The [Agent Commons](https://marketplace.mendix.com/link/component/239450) module enables users to develop, test, and optimize their GenAI use cases by creating effective agents that interact with large language models (LLMs).
+With the Agent Commons module, you can use the Agent Builder interface within your app to define agents at runtime and manage multiple versions over time.
+
+You can wire up prompts, microflows (as tools), knowledge bases, and large language models to build agentic patterns that support your business logic. The Agent Builder also allows you to define variables that act as placeholders for data from the app session context, which are replaced with actual values when the end user interacts with the app.
+
+The Agent Commons module includes the necessary data model, pages, and snippets to seamlessly integrate the agent builder interface into your app and start using agents within your app logic.
+
+### Typical Use Cases
+
+Typical use cases for Agent Commons include:
+
+* Incorporating one or more agentic patterns in the app that involve interactions with an LLM. These patterns may also include microflows as tools, knowledge bases, and guardrails.
+
+* Enabling prompt updates or improvements without modifying the underlying LLM integration code or low-code application logic. This allows non-developers, such as data scientists, to change prompts and iterate on agent configurations.
+
+* Supporting rapid iteration on prompts, microflows, knowledge bases, models, and variable placeholders in a playground setup, separate from core app logic.
+
+### Features
+
+The Agent Commons module offers the following features:
+
+* Agent Builder UI components and data model for managing, storing, and rapidly iterating on agent versions at runtime. No app deployment is required to update an agent.
+
+* Drag and drop operations for calling both single-call and conversational agents from microflows and workflows.
+
+* Prompt placeholders, allowing dynamic insertion of values based on user or context objects at runtime.
+
+* Logic to define and run tests individually or in bulk, with result comparisons.
+
+* Export/import functionality for transporting agents across different app environments (for example, local, acceptance, production).
+
+* The ability to manage the active agent version used by the app logic in the app environment eliminates the need for redeployment.
+
+{{% alert color="info" %}} The current scope of the module focuses on LLM invocations using a variety of prompts, optionally enhanced with placeholders (variables). Agents can be further extended by integrating microflows with a single parameter as tools using the [Function Calling](/appstore/modules/genai/function-calling/) setup, and by connecting to knowledge bases provided through [Mendix Cloud GenAI Resources](/appstore/modules/genai/mx-cloud-genai/resource-packs/#knowledge-bases). {{% /alert %}}
+
+### Dependencies {#dependencies}
+
+The Agent Commons module requires Mendix Studio Pro version [10.21.0](/releasenotes/studio-pro/10.21/#10210) or above.
+
+In addition, install the following modules:
+
+* [Community Commons](https://marketplace.mendix.com/link/component/170)
+* [GenAI Commons](https://marketplace.mendix.com/link/component/239448)
+* [Mendix Cloud GenAI Connector](https://marketplace.mendix.com/link/component/239449)
+* [Conversational UI](https://marketplace.mendix.com/link/component/239450)
+
+## Installation
+
+If you are starting from a blank app or adding agent-building functionality to an existing project, you need to manually install the [Agent Commons](https://marketplace.mendix.com/link/component/239450) module from the Mendix Marketplace.
+Before proceeding, ensure your project includes the latest versions of the required [dependencies](#dependencies). Follow the instructions in [How to Use Marketplace Content](/appstore/use-content/) to install the Agent Commons module.
+
+## Configuration
+
+To use the Agent Commons functionalities in your app, you must perform the following tasks in Studio Pro:
+
+1. Assign the relevant [module roles](#module-roles) to the applicable user roles in the project **Security**.
+2. Add the [Agent Builder UI to your app](#ui-components) by using the pages and snippets as a basis.
+3. Ensure that a [deployed model](#deployed-models) is configured.
+4. [Define](#define-prompt) the prompts, add functions, knowledge bases, and test the agent.
+5. Add the agent to the app [logic](#app-logic) of your specific use case.
+6. Improve and [iterate on agent versions](#improve-agent).
+
+### Configuring the Roles {#module-roles}
+
+In the project **Security** of your app, assign the **AgentCommons.AgentAdmin** module role to user roles responsible for defining and refining agents, as well as selecting the active agent version used in the running app environment.
+
+### Adding the Agent Builder UI to Your App {#ui-components}
+
+The module includes a set of reusable pages, layouts, and snippets, allowing you to add the agent builder to your app.
+
+#### Pages and Layouts
+
+To define the agents at runtime, add the **Agent_Overview** page (**USE_ME** > **Agent Builder**) to your app **Navigation**, or include the **Snippet_Agent_Overview** in a page that is already part of your navigation.
+
+From the overview, users can access the **Version_Details** page to edit prompts and run tests. For more customization, you can refer to the contents of **Snippet_Agent_Details**.
+
+If you need to adjust the layout or apply other customizations, it is recommended to copy the relevant page into your own module and modify it to match your app styling or use case.
+
+For example, download and run the [Agent Builder Starter App](https://marketplace.mendix.com/link/component/240369) to see the pages in action.
+
+### Configuring Deployed Models {#deployed-models}
+
+To interact with LLMs using Agent Commons, you need at least one GenAI connector that adheres to the GenAI Commons principles. To test agent behavior, you must configure at least one [Deployed Model](/appstore/modules/genai/genai-for-mx/commons/#deployed-model) for your chosen connector. Refer to the specific connector’s documentation for detailed instructions on setting up the Deployed Model.
+
+* For [Mendix Cloud GenAI](https://marketplace.mendix.com/link/component/239449), importing the **Key** from the Mendix portal automatically creates a MxCloud Deployed Model. This is part of the [configuration](/appstore/modules/genai/mx-cloud-genai/MxGenAI-connector/#configuration).
+* For [Amazon Bedrock](https://marketplace.mendix.com/link/component/215042), the creation of Bedrock Deployed Models is part of the [model synchronization mechanism](/appstore/modules/aws/amazon-bedrock/#sync-models).
+* For [OpenAI](https://marketplace.mendix.com/link/component/220472), the configuration of OpenAI Deployed Models is part of the [configuration](/appstore/modules/genai/reference-guide/external-connectors/openai/#general-configuration).
+
+### Defining the Agent {#define-prompt}
+
+When the app is running, a user with the `AgentAdmin` role can set up agents, write prompts, link microflows as tools, and provide access to knowledge bases. Once an agent is associated with a deployed model, it can be tested in an isolated environment, separate from the rest of the app’s logic, to validate its behavior effectively.
+
+Users can create two types of agents:
+
+* Conversational Agent: Intended for scenarios where the end user interacts through a chat interface, or where the agent is called conversationally by another agent.
+
+* Single-Call Agent: Designed for isolated agentic patterns such as background processes, subagents in an Agent-as-Tool setup, or any use case that doesn't require a conversational interface with historical context.
+
+ {{< figure src="/attachments/appstore/platform-supported-content/modules/genai/agentcommons/agentbuilderUI.png" >}}
+
+#### Defining Context Entity
+
+If your agent's prompt includes variables, your app must define an entity with attributes that match the variable names. An object of this entity serves as the context object, which holds the context data that will be passed when the **call agent** operation is triggered. For more details, see the [Use the agent in the app logic](#app-logic) section below.
+
+This object contains the actual values that will be inserted into the prompt texts where the variables were defined. To link the context entity to the agent, select it in the Agent Commons UI. If you have created a new entity, run the app locally first to ensure it appears in the selection list.
+
+The `AgentAdmin` will see warnings on the Agent Version Details page if:
+
+* The entity has not been selected
+
+* The entity's attributes do not match the defined variables
+
+* The attribute length is insufficient to hold the actual values when logic is executed in the running app.
+
+#### Adding Microflows as Tools
+
+To allow your agent to act dynamically and autonomously or to access specific data based on input it determines, microflows can be added as tools. When the agent is invoked, it uses the function calling pattern to execute the required microflows, using the input specified in the model’s response.
+
+For more technical details, see the [Function Calling](/appstore/modules/genai/function-calling/) documentation.
+
+#### Adding Knowledge Bases
+
+For supported knowledge bases registered in your app, you can connect them to agents to enable autonomous retrievals. To set this up, refer to the documentation of the connector provided by your chosen knowledge base provider and follow the instructions for establishing a connection from your app.
+
+To allow the agent to perform semantic searches, add the knowledge base to the agent definition and configure the retrieval parameters, such as metadata filters, the number of chunks to retrieve, and the threshold similarity.
+
+#### Testing and Refining the Agent
+
+While writing the system prompt (for both conversational and single-call types) or the user prompt (only for the single-call type), the prompt engineer can include variables by enclosing them in double braces, for example, `{{variable}}`. The actual values of these placeholders are typically known at runtime based on the user's page context.
+To test the behavior of the prompts, a test can be executed. The prompt engineer must provide test values for all variables defined in the prompts. Additionally, multiple sets of test values for the variables can be defined and run in bulk. Based on the test results, the prompt engineer can add, remove, or rephrase certain parts of the prompt.
+
+### Using the Agent in the App Logic {#app-logic}
+
+After a few quick iterations, the first version of the agent is typically ready to be saved and integrated into the application logic for end-user testing. To do this, you can add one of the available operations from the Agent Commons module into your app logic.
+
+#### Creating a Version
+
+New agents will be created in the draft status by default, meaning they are still being worked on and can be tested using the agent commons module only. Once an agent is ready to be integrated into the app logic (i.e., logic triggered by end users), it must be saved as a version. This will store a snapshot of the prompt texts and the configured microflows as tools and knowledge bases. To select the active version for the agent, use the three-dot ({{% icon name="three-dots-menu-horizontal" %}}) menu option on the agent overview and click **Select Version in use**.
+
+#### Calling the Agent from a Microflow
+
+For most use cases, the `Call Agent` microflow activity can be used. You can find this operation in Studio Pro **Toolbox**, under the **Agents Kit** category while editing a microflow.
+
+To use it:
+
+1. Create a Request object using either the [GenAI Commons operation](/appstore/modules/genai/genai-for-mx/commons/#chat-create-request) or the [Default Preprocessing from ConversationalUI](/appstore/modules/genai/conversational-ui-module/).
+2. Ensure the Agent object is in scope, for example, retrieve it from the database by name.
+3. Pass both the Request and Agent objects to the `Call Agent` activity.
+
+This action calls the Agent using the specified Request and executes a `Chat Completions (With History)` operation based on a defined agent. It uses all defined settings, including the selected model, system prompt, tools, knowledge base, and model parameters. The operation returns a Response object containing the assistant’s final message, in the same fashion as the chat completions operations from GenAI Commons.
+
+For more specific use cases, where a context object is required for variable replacement, use the `Get Prompt for Context Object`. You can find this in Studio Pro **Toolbox**, under the **Agents Kit** category while editing a microflow.
+
+
+This operation returns both the system prompt and user prompt as string attributes within a combined `PromptToUse` object. These prompt strings can then be passed to a Chat Completions operation.
+
+To use this setup:
+
+1. Retrieve the relevant Agent one more time (for example, by name) and pass it with your custom context object to the operation.
+
+2. In a similar way to the Call Agent activity, use the `Request_AddAgentCapabilities` microflow to apply the agent's properties to the request.
+
+3. Finally, place the required Chat Completions operation (with or without history) after this step to invoke the agent.
+
+For a conversational agent, the chat context can be created based on the agent in one convenient operation. Use the `New Chat for Agent` operation from the **Toolbox** under the **Agents Kit** category. Retrieve the agent (for example, by name) and pass it with your custom context object to the operation. Note that this sets the system prompt for the chat context, making it applicable to the entire (future) conversation. Similar to other chat context operations, an [action microflow needs to be selected](/appstore/modules/genai/conversational-ui-module/conversational-ui/#action-microflow) for this microflow action.
+
+{{% alert color="info" %}}
+Download the [Agent Builder Starter App](https://marketplace.mendix.com/link/component/240369) from the Marketplace for a detailed example of how to use the **Call Agent** activity in an action microflow of a chat interface.
+{{% /alert %}}
+
+#### Transporting the Agent to Other Environments
+
+With the above microflow logic, the agent version is ready to be tested within the end-user flow, either in a local or test environment. Additionally, the agent can be exported and imported for transport to other environments when needed.
+
+To export the agent, use the export button on the page where the agent is edited, or use the export and import buttons available on the overview page.
+
+If context objects or functions have been modified, ensure that the correct version of the project is deployed before importing the new agent definition. This ensures that the domain model and microflows are aligned with the new agent version.
+
+### Improving the Agent {#improve-agent}
+
+When an agent version is saved, a button is available to create a new draft version. You can use the new draft as a starting point to make small changes or improvements based on feedback, either from testing or after the agent has been live for some time, and new scenarios need to be covered.
+
+#### Creating Multiple Versions
+
+The new draft version will initially have the same prompt texts, tools, and linked knowledge bases as the latest version. You can then modify the prompt texts to cover additional scenarios, and update the tools and knowledge bases by adding, removing, or editing them as needed. Once the improved agent is ready, it can be saved as a new version.
+
+#### Managing In-Use Version per Environment
+
+Each time a new version of the agent is created, a decision must be made regarding which version to use in the end-user logic. Mendix recommends evaluating the active version as part of the testing and release process.
+
+When importing new agents into other environments, selecting the in-use version is always a manual step, requiring a conscious decision. The user will be prompted to choose the version to be used as part of the import user flow. Later, you can manage the active version directly from the Agent Overview.
+
+ {{< figure src="/attachments/appstore/platform-supported-content/modules/genai/agentcommons/Select_in_use.png" >}}
+
+## Technical Reference
+
+The module includes technical reference documentation for the available entities, enumerations, activities, and other items that you can use in your application. You can view the information about each object in context by using the **Documentation** pane in Studio Pro.
+
+The **Documentation** pane displays the documentation for the currently selected element. To view it, perform the following steps:
+
+1. In the [View menu](/refguide/view-menu/) of Studio Pro, select **Documentation**.
+2. Click the element for which you want to view the documentation.
+
+ {{< figure src="/attachments/appstore/platform-supported-content/modules/technical-reference/doc-pane.png" >}}
diff --git a/static/attachments/appstore/platform-supported-content/modules/genai/agentcommons/Select_in_use.png b/static/attachments/appstore/platform-supported-content/modules/genai/agentcommons/Select_in_use.png
new file mode 100644
index 00000000000..745863a67f0
Binary files /dev/null and b/static/attachments/appstore/platform-supported-content/modules/genai/agentcommons/Select_in_use.png differ
diff --git a/static/attachments/appstore/platform-supported-content/modules/genai/agentcommons/agentbuilderUI.png b/static/attachments/appstore/platform-supported-content/modules/genai/agentcommons/agentbuilderUI.png
new file mode 100644
index 00000000000..3fb1a48d3a3
Binary files /dev/null and b/static/attachments/appstore/platform-supported-content/modules/genai/agentcommons/agentbuilderUI.png differ
diff --git a/static/attachments/appstore/platform-supported-content/modules/genai/agents/Evaluator-optimizer.svg b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Evaluator-optimizer.svg
new file mode 100644
index 00000000000..0c3f9a24814
--- /dev/null
+++ b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Evaluator-optimizer.svg
@@ -0,0 +1,169 @@
+
diff --git a/static/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining-Gatekeeper.svg b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining-Gatekeeper.svg
new file mode 100644
index 00000000000..05cd7b15acd
--- /dev/null
+++ b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining-Gatekeeper.svg
@@ -0,0 +1,280 @@
+
diff --git a/static/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining.svg b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining.svg
new file mode 100644
index 00000000000..eec1eba034c
--- /dev/null
+++ b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Linear-Chaining.svg
@@ -0,0 +1,197 @@
+
diff --git a/static/attachments/appstore/platform-supported-content/modules/genai/agents/Routing.svg b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Routing.svg
new file mode 100644
index 00000000000..485b7f730e0
--- /dev/null
+++ b/static/attachments/appstore/platform-supported-content/modules/genai/agents/Routing.svg
@@ -0,0 +1,238 @@
+