> For the complete documentation index, see [llms.txt](https://swarmreasoning.gitbook.io/miao16z/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://swarmreasoning.gitbook.io/miao16z/roadmap/fractionalization.md).

# Fractionalization

#### **In-Depth Explanation of Fractionalization for Custom Imported Agents**

**Fractionalization** in the Miao Swarm framework enables custom imported agents to be divided into smaller, specialized sub-agents. This process allows the system to leverage the expertise of a single imported agent across multiple subtasks, enhancing parallelism, scalability, and task-specific focus.

***

#### **What is Fractionalization?**

Fractionalization is the process of breaking down a fully integrated custom agent into multiple sub-agents, each tailored to handle specific subtasks of a larger problem. The goal is to optimize resource utilization and task execution while maintaining coherence in the overall workflow.

***

#### **Key Components of Fractionalization**

1. **Task Decomposition:**
   * The system analyzes the primary task assigned to the custom agent and identifies independent subtasks.
   * Example: A healthcare analytics agent might be fractionalized into sub-agents for patient diagnosis, resource allocation, and trend prediction.
2. **Sub-Agent Creation:**
   * Each sub-agent inherits the core capabilities of the parent agent but is configured for a specific subtask.
   * Sub-agents operate autonomously, allowing for parallel processing.
3. **Dynamic Specialization:**
   * Sub-agents are dynamically optimized for their assigned subtasks using parameters like temperature, focus, and resource allocation.
   * Example: A sub-agent for data analysis might have a high-temperature setting for creative insights, while a reporting sub-agent operates at low temperature for precision.
4. **Reintegration:**
   * Upon task completion, outputs from sub-agents are aggregated and reconciled to form a unified result.
   * The main agent evolves by integrating the knowledge and results from its sub-agents.

***

#### **Fractionalization Workflow**

1. **Import Custom Agent:**
   * The custom agent is registered within the Miao framework and evaluated for compatibility.
   * Example: A financial analytics agent trained externally is imported into the swarm.
2. **Task Analysis and Decomposition:**
   * The system evaluates the agent’s expertise and the complexity of the assigned task.
   * Subtasks are defined, such as risk assessment, portfolio optimization, and market trend analysis.
3. **Sub-Agent Initialization:**
   * Sub-agents are instantiated with specialized configurations for each subtask.
   * Example: `RiskAI`, `PortfolioAI`, and `MarketAI` are sub-agents derived from the financial analytics agent.
4. **Parallel Execution:**
   * Sub-agents execute their subtasks independently, communicating intermediate results as necessary.
5. **Collaboration and Integration:**
   * The outputs of sub-agents are reconciled in the reasoning stage to ensure alignment with the overarching task.
6. **Knowledge Update:**
   * The parent agent integrates the results and any learned parameters from its sub-agents for future improvements.

```
class CustomAgent:
    def __init__(self, name):
        self.name = name
        self.sub_agents = []

    def fractionalize(self, subtasks):
        # Create sub-agents for each subtask
        self.sub_agents = [SubAgent(name=f"{self.name}_Sub{i+1}", task=task) for i, task in enumerate(subtasks)]
        return self.sub_agents

    def reintegrate(self):
        # Aggregate results from sub-agents
        unified_output = " | ".join([agent.output for agent in self.sub_agents])
        return f"{self.name} unified output: {unified_output}"


class SubAgent:
    def __init__(self, name, task):
        self.name = name
        self.task = task
        self.output = None

    def execute(self):
        # Simulate task execution
        self.output = f"{self.name} completed {self.task}"
        return self.output


# Example Usage
custom_agent = CustomAgent(name="FinancialAI")
subtasks = ["Risk Assessment", "Portfolio Optimization", "Market Trend Analysis"]

# Fractionalize
sub_agents = custom_agent.fractionalize(subtasks)
for agent in sub_agents:
    print(agent.execute())

# Reintegration
print(custom_agent.reintegrate())

```


---

# 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://swarmreasoning.gitbook.io/miao16z/roadmap/fractionalization.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.