> For the complete documentation index, see [llms.txt](https://docs.amesa.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.amesa.com/build-multi-agent-systems/import-agent-components-to-the-ui.md).

# Import Agents to the Agent Orchestration Studio

## Import Skill Agents into AMESA

AMESA makes it easy to **import existing logic and controllers**, from MPC and PID controllers to custom Python applications and machine learning models. Once imported, these agents can be reused across your use cases and visually orchestrated in the Agent Orchestration Studio.

Whether you’ve built your logic using AMESA’s Agent Training Library or you're wrapping existing IP (e.g., LLMs, external APIs, heuristics), you can import it into AMESA and make it available for drag-and-drop integration.

You can import agents[^1], orchestrators[^2], and perceptors[^3].

***

### Why Import Agents?

Many organizations already rely on proven control strategies, models, or code. Importing them into AMESA allows you to:

* **Re-use your existing IP** in a composable agent system
* **Combine logic-based and learning-based agents** (e.g., hybrid PID + DRL setups)
* **Standardize deployment workflows** across your team or organization

***

### How to Import Skill Agents and Orchestrators

1. **Log in to AMESA**

   ```bash
   amesa login
   ```

You’ll be redirected to the browser to enter your credentials.

2. Navigate to your agent directory

   Change to the folder containing the skill agent or orchestrator you want to import.
3. Import the component
   * For an agent:

```
amesa agent publish agent-name
```

* For an orchestrator:

```
amesa orchestrator publish orchestrator-name
```

4. Choose where to save it
   * Select your organization
   * Select the project or use case
5. Finish importing

   Once the import is complete:

   * Open the UI
   * Go to Agent Orchestration Studio
   * Refresh your browser

   Your new skill agent or orchestrator will appear in the sidebar, ready to use.

### Importing Perceptors

1. Navigate to the Perceptors Directory

Move to the folder above the individual perceptor you want to import.

2. Import a Perceptor

```
composabl perceptor publish perceptor-name
```

3. Select Your Organization and Use Case
4. Complete the Import

   After import:

   * Go to the UI
   * Open Agent Orchestration Studio
   * Refresh the page

   Your perceptor will appear in the sidebar and can be connected to agents.

***

### What Can You Import?

You can import nearly any Python-based logic as a skill agent, including:

* PID or MPC controllers
* LLM-based agents
* Business rule engines
* ML models or custom inference code
* External API wrappers

Once imported, these agents can be composed into intelligent multi-agent systems alongside AMESA-native components.

[^1]: Modules within a multi-agent system that make decisions to complete all or part of a task

[^2]: A special type of skill agent that assigns decision-making control to the right decision-making skill agent based on current conditions

[^3]: An ML model or other algorithm that interprets sensor data


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.amesa.com/build-multi-agent-systems/import-agent-components-to-the-ui.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.