fast-agent-mcp 0.0.8__tar.gz → 0.0.9__tar.gz

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.0.8
+Version: 0.0.9
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -252,13 +252,15 @@ Description-Content-Type: text/markdown
 
 Install the [uv package manager](https://docs.astral.sh/uv/).
 
-`uv pip install fast-agent-mcp` - download fast-agent
+`uv pip install fast-agent-mcp` - download and install fast-agent
 
 `fast-agent setup` - setup an agent and configuration files.
 
 `uv run agent.py` - run and interact with your first agent.
 
-`fast-agent bootstrap workflow` - generate example agents demonstrating each of the workflows from Anthropic's "[Building Effective Agents](https://www.anthropic.com/research/building-effective-agents)" paper.
+`fast-agent bootstrap workflow` - generate example agents and workflows demonstrating each of the patterns from Anthropic's "[Building Effective Agents](https://www.anthropic.com/research/building-effective-agents)" paper.
+
+`fast-agent bootstrap` - 
 
 It's built on top of [mcp-agent](todo).
 

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/README.md

@@ -16,13 +16,15 @@
 
 Install the [uv package manager](https://docs.astral.sh/uv/).
 
-`uv pip install fast-agent-mcp` - download fast-agent
+`uv pip install fast-agent-mcp` - download and install fast-agent
 
 `fast-agent setup` - setup an agent and configuration files.
 
 `uv run agent.py` - run and interact with your first agent.
 
-`fast-agent bootstrap workflow` - generate example agents demonstrating each of the workflows from Anthropic's "[Building Effective Agents](https://www.anthropic.com/research/building-effective-agents)" paper.
+`fast-agent bootstrap workflow` - generate example agents and workflows demonstrating each of the patterns from Anthropic's "[Building Effective Agents](https://www.anthropic.com/research/building-effective-agents)" paper.
+
+`fast-agent bootstrap` - 
 
 It's built on top of [mcp-agent](todo).
 

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.0.8"
+version = "0.0.9"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/cli/commands/bootstrap.py

@@ -269,6 +269,9 @@ def _show_completion_message(example_type: str, created: list[str]):
             )
             console.print("2. The dataset is available in the mount-point directory:")
             console.print("   - mount-point/WA_Fn-UseC_-HR-Employee-Attrition.csv")
+            console.print(
+                "On Windows platforms, please edit the fastagent.config.yaml and adjust the volume mount point."
+            )
     else:
         console.print("\n[yellow]No files were created.[/yellow]")
 

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/core/fastagent.py

@@ -31,9 +31,10 @@ from rich.prompt import Prompt
 from rich import print
 from mcp_agent.progress_display import progress_display
 from mcp_agent.workflows.llm.model_factory import ModelFactory
-from mcp_agent.workflows.llm.augmented_llm import RequestParams
+from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM, RequestParams
 
-import readline  # noqa: F401
+# TODO -- resintate once Windows&Python 3.13 platform issues are fixed
+# import readline  # noqa: F401
 
 # Type aliases for better readability
 WorkflowType: TypeAlias = Union[
@@ -334,7 +335,8 @@ class FastAgent(ContextDependent):
     def _validate_workflow_references(self) -> None:
         """
         Validate that all workflow references point to valid agents/workflows.
-        Raises ValueError if any referenced components are not defined.
+        Also validates that referenced agents have required configuration.
+        Raises AgentConfigError if any validation fails.
         """
         available_components = set(self.agents.keys())
 
@@ -358,7 +360,7 @@ class FastAgent(ContextDependent):
                     )
 
             elif agent_type == AgentType.ORCHESTRATOR.value:
-                # Check all child agents exist
+                # Check all child agents exist and are properly configured
                 child_agents = agent_data["child_agents"]
                 missing = [a for a in child_agents if a not in available_components]
                 if missing:
@@ -366,6 +368,18 @@ class FastAgent(ContextDependent):
                         f"Orchestrator '{name}' references non-existent agents: {', '.join(missing)}"
                     )
 
+                # Validate child agents have required LLM configuration
+                for agent_name in child_agents:
+                    child_data = self.agents[agent_name]
+                    if child_data["type"] == AgentType.BASIC.value:
+                        # For basic agents, we'll validate LLM config during creation
+                        continue
+                    elif not isinstance(child_data["func"], AugmentedLLM):
+                        raise AgentConfigError(
+                            f"Agent '{agent_name}' used by orchestrator '{name}' lacks LLM capability",
+                            "All agents used by orchestrators must be LLM-capable",
+                        )
+
             elif agent_type == AgentType.ROUTER.value:
                 # Check all referenced agents exist
                 router_agents = agent_data["agents"]
@@ -432,7 +446,7 @@ class FastAgent(ContextDependent):
         *,
         instruction: str = "You are a helpful agent.",
         servers: List[str] = [],
-        model: Optional[str] = None,
+        model: str | None = None,
         use_history: bool = True,
         request_params: Optional[Dict] = None,
         human_input: bool = False,
@@ -482,11 +496,12 @@ class FastAgent(ContextDependent):
 
     def orchestrator(
         self,
-        name: str,
-        instruction: str,
+        name: str = "Orchestrator",
+        *,
+        instruction: str | None = None,
         agents: List[str],
         model: str | None = None,
-        use_history: bool = True,
+        use_history: bool = False,
         request_params: Optional[Dict] = None,
         human_input: bool = False,
     ) -> Callable:
@@ -498,14 +513,14 @@ class FastAgent(ContextDependent):
             instruction: Base instruction for the orchestrator
             agents: List of agent names this orchestrator can use
             model: Model specification string (highest precedence)
-            use_history: Whether to maintain conversation history
+            use_history: Whether to maintain conversation history (forced false)
             request_params: Additional request parameters for the LLM
         """
 
         def decorator(func: Callable) -> Callable:
             # Create base request params
             base_params = RequestParams(
-                use_history=use_history, **(request_params or {})
+                use_history=use_history, model=model, **(request_params or {})
             )
 
             # Create agent configuration
@@ -721,7 +736,7 @@ class FastAgent(ContextDependent):
 
         return active_agents
 
-    def _create_orchestrators(
+    async def _create_orchestrators(
         self, agent_app: MCPApp, active_agents: ProxyDict
     ) -> ProxyDict:
         """
@@ -739,44 +754,57 @@ class FastAgent(ContextDependent):
             if agent_data["type"] == AgentType.ORCHESTRATOR.value:
                 config = agent_data["config"]
 
-                # TODO: Remove legacy - This model/params setup should be in Agent class
-                # Resolve model alias if present
-                model_config = ModelFactory.parse_model_string(config.model)
-                resolved_model = model_config.model_name
-
-                # Start with existing params if available
-                if config.default_request_params:
-                    base_params = config.default_request_params.model_copy()
-                    # Update with orchestrator-specific settings
-                    base_params.use_history = config.use_history
-                    base_params.model = resolved_model
-                else:
-                    base_params = RequestParams(
-                        use_history=config.use_history, model=resolved_model
-                    )
-
-                llm_factory = self._get_model_factory(
-                    model=config.model,  # Use original model string for factory creation
-                    request_params=base_params,
+                # Get base params configured with model settings
+                base_params = (
+                    config.default_request_params.model_copy()
+                    if config.default_request_params
+                    else RequestParams()
                 )
+                base_params.use_history = False  # Force no history for orchestrator
 
-                # Get the child agents - need to unwrap proxies
+                # Get the child agents - need to unwrap proxies and validate LLM config
                 child_agents = []
                 for agent_name in agent_data["child_agents"]:
                     proxy = active_agents[agent_name]
-                    if isinstance(proxy, LLMAgentProxy):
-                        child_agents.append(proxy._agent)  # Get the actual Agent
-                    else:
-                        # Handle case where it might be another workflow
-                        child_agents.append(proxy._workflow)
+                    instance = self._unwrap_proxy(proxy)
+                    # Validate basic agents have LLM
+                    if isinstance(instance, Agent):
+                        if not hasattr(instance, "_llm") or not instance._llm:
+                            raise AgentConfigError(
+                                f"Agent '{agent_name}' used by orchestrator '{name}' missing LLM configuration",
+                                "All agents must be fully configured with LLMs before being used in an orchestrator",
+                            )
+                    child_agents.append(instance)
+
+                # Create a properly configured planner agent
+                planner_config = AgentConfig(
+                    name=f"{name}",  # Use orchestrator name as prefix
+                    instruction=config.instruction
+                    or """
+                    You are an expert planner. Given an objective task and a list of MCP servers (which are collections of tools)
+                    or Agents (which are collections of servers), your job is to break down the objective into a series of steps,
+                    which can be performed by LLMs with access to the servers or agents.
+                    """,
+                    servers=[],  # Planner doesn't need server access
+                    model=config.model,  # Use same model as orchestrator
+                    default_request_params=base_params,
+                )
+                planner_agent = Agent(config=planner_config, context=agent_app.context)
+                planner_factory = self._get_model_factory(
+                    model=config.model,
+                    request_params=config.default_request_params,
+                )
 
+                async with planner_agent:
+                    planner = await planner_agent.attach_llm(planner_factory)
+
+                # Create the orchestrator with pre-configured planner
                 orchestrator = Orchestrator(
                     name=config.name,
-                    instruction=config.instruction,
+                    planner=planner,  # Pass pre-configured planner
                     available_agents=child_agents,
                     context=agent_app.context,
-                    llm_factory=llm_factory,
-                    request_params=base_params,  # Use our base params that include model
+                    request_params=planner.default_request_params,  # Base params already include model settings
                     plan_type="full",
                 )
 
@@ -784,6 +812,7 @@ class FastAgent(ContextDependent):
                 orchestrators[name] = self._create_proxy(
                     name, orchestrator, AgentType.ORCHESTRATOR.value
                 )
+
         return orchestrators
 
     async def _create_evaluator_optimizers(
@@ -878,7 +907,7 @@ class FastAgent(ContextDependent):
 
         return deps
 
-    def _create_parallel_agents(
+    async def _create_parallel_agents(
         self, agent_app: MCPApp, active_agents: ProxyDict
     ) -> ProxyDict:
         """
@@ -946,7 +975,9 @@ class FastAgent(ContextDependent):
 
         return parallel_agents
 
-    def _create_routers(self, agent_app: MCPApp, active_agents: ProxyDict) -> ProxyDict:
+    async def _create_routers(
+        self, agent_app: MCPApp, active_agents: ProxyDict
+    ) -> ProxyDict:
         """
         Create router agents.
 
@@ -1029,14 +1060,18 @@ class FastAgent(ContextDependent):
                 self._validate_server_references()
                 self._validate_workflow_references()
 
-                # Create all types of agents
+                # Create all types of agents in dependency order
                 active_agents = await self._create_basic_agents(agent_app)
-                orchestrators = self._create_orchestrators(agent_app, active_agents)
-                parallel_agents = self._create_parallel_agents(agent_app, active_agents)
+                orchestrators = await self._create_orchestrators(
+                    agent_app, active_agents
+                )
+                parallel_agents = await self._create_parallel_agents(
+                    agent_app, active_agents
+                )
                 evaluator_optimizers = await self._create_evaluator_optimizers(
                     agent_app, active_agents
                 )
-                routers = self._create_routers(agent_app, active_agents)
+                routers = await self._create_routers(agent_app, active_agents)
 
                 # Merge all agents into active_agents
                 active_agents.update(orchestrators)

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/resources/examples/data-analysis/analysis.py

@@ -7,7 +7,7 @@ fast = FastAgent("Data Analysis (Roots)")
 
 
 @fast.agent(
-    name="Data_Analysis",
+    name="data_analysis",
     instruction="""
 You have access to a Python 3.12 interpreter and you can use this to analyse and process data. 
 Common analysis packages such as Pandas, Seaborn and Matplotlib are already installed. 

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/resources/examples/data-analysis/fastagent.config.yaml

@@ -1,5 +1,7 @@
 default_model: sonnet
 
+# on windows, adjust the mount point to be the full path e.g. x:/temp/data-analysis/mount-point:/mnt/data/
+
 mcp:
   servers:
     interpreter:

fast_agent_mcp-0.0.9/src/mcp_agent/resources/examples/workflows/fastagent.config.yaml

@@ -0,0 +1,9 @@
+default_model: sonnet
+mcp:
+    servers:
+        fetch:
+            command: "uvx"
+            args: ["mcp-server-fetch"]
+        filesystem:
+            command: "npx"
+            args: ["@modelcontextprotocol/server-filesystem","."]

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/resources/examples/workflows/human_input.py

@@ -13,7 +13,6 @@ fast = FastAgent("Human Input")
 @fast.agent(
     instruction="An AI agent that assists with basic tasks. Request Human Input when needed.",
     human_input=True,
-    model="gpt-4o",
 )
 async def main():
     async with fast.run() as agent:

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/resources/examples/workflows/orchestrator.py

@@ -44,12 +44,6 @@ fast = FastAgent("Orchestrator-Workers")
 # Define the orchestrator to coordinate the other agents
 @fast.orchestrator(
     name="orchestrate",
-    instruction="""Load the student's short story from short_story.md, 
-    and generate a report with feedback across proofreading, 
-    factuality/logical consistency and style adherence. Use the style rules from 
-    https://apastyle.apa.org/learn/quick-guide-on-formatting and 
-    https://apastyle.apa.org/learn/quick-guide-on-references.
-    Write the graded report to graded_report.md in the same directory as short_story.md""",
     agents=["finder", "writer", "proofreader"],
     model="sonnet",
 )

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -79,25 +79,8 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         Process a query using an LLM and available tools.
         Override this method to use a different LLM.
         """
-        config = self.context.config
 
-        api_key = None
-
-        if hasattr(config, "anthropic") and config.anthropic:
-            api_key = config.anthropic.api_key
-            if api_key == "<your-api-key-here>":
-                api_key = None
-
-        if api_key is None:
-            api_key = os.getenv("ANTHROPIC_API_KEY")
-
-        if not api_key:
-            raise ProviderKeyError(
-                "Anthropic API key not configured",
-                "The Anthropic API key is required but not set.\n"
-                "Add it to your configuration file under anthropic.api_key "
-                "or set the ANTHROPIC_API_KEY environment variable.",
-            )
+        api_key = self._api_key(self.context.config)
         try:
             anthropic = Anthropic(api_key=api_key)
             messages: List[MessageParam] = []
@@ -264,6 +247,27 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         return responses
 
+    def _api_key(self, config):
+        api_key = None
+
+        if hasattr(config, "anthropic") and config.anthropic:
+            api_key = config.anthropic.api_key
+            if api_key == "<your-api-key-here>":
+                api_key = None
+
+        if api_key is None:
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+
+        if not api_key:
+            raise ProviderKeyError(
+                "Anthropic API key not configured",
+                "The Anthropic API key is required but not set.\n"
+                "Add it to your configuration file under anthropic.api_key "
+                "or set the ANTHROPIC_API_KEY environment variable.",
+            )
+
+        return api_key
+
     async def generate_str(
         self,
         message,
@@ -313,7 +317,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         # Next we pass the text through instructor to extract structured data
         client = instructor.from_anthropic(
-            Anthropic(api_key=self.context.config.anthropic.api_key),
+            Anthropic(api_key=self._api_key(self.context.config)),
         )
 
         params = self.get_request_params(request_params)

{fast_agent_mcp-0.0.8 → fast_agent_mcp-0.0.9}/src/mcp_agent/workflows/orchestrator/orchestrator.py

@@ -2,9 +2,7 @@
 Orchestrator implementation for MCP Agent applications.
 """
 
-import contextlib
 from typing import (
-    Callable,
     List,
     Literal,
     Optional,
@@ -12,7 +10,7 @@ from typing import (
     TYPE_CHECKING,
 )
 
-from mcp_agent.agents.agent import Agent, AgentConfig
+from mcp_agent.agents.agent import Agent
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     MessageParamT,
@@ -20,7 +18,6 @@ from mcp_agent.workflows.llm.augmented_llm import (
     ModelT,
     RequestParams,
 )
-from mcp_agent.workflows.llm.model_factory import ModelFactory
 from mcp_agent.workflows.orchestrator.orchestrator_models import (
     format_plan_result,
     format_step_result,
@@ -47,9 +44,9 @@ logger = get_logger(__name__)
 
 class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
     """
-    In the orchestrator-workers workflow, a central LLM dynamically breaks down tasks,
-    delegates them to worker LLMs, and synthesizes their results. It does this
-    in a loop until the task is complete.
+    In the orchestrator-workers workflow, a central planner LLM dynamically breaks down tasks and
+    delegates them to pre-configured worker LLMs. The planner synthesizes their results in a loop
+    until the task is complete.
 
     When to use this workflow:
         - This workflow is well-suited for complex tasks where you can't predict the
@@ -60,65 +57,59 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         - Coding products that make complex changes to multiple files each time.
         - Search tasks that involve gathering and analyzing information from multiple sources
         for possible relevant information.
+
+    Note:
+        All agents must be pre-configured with LLMs before being passed to the orchestrator.
+        This ensures consistent model behavior and configuration across all components.
     """
 
     def __init__(
         self,
-        llm_factory: Callable[[Agent], AugmentedLLM[MessageParamT, MessageT]],
-        planner: AugmentedLLM | None = None,
-        available_agents: List[Agent | AugmentedLLM] | None = None,
+        name: str,
+        planner: AugmentedLLM,  # Pre-configured planner
+        available_agents: List[Agent | AugmentedLLM],
         plan_type: Literal["full", "iterative"] = "full",
         context: Optional["Context"] = None,
         **kwargs,
     ):
         """
         Args:
-            llm_factory: Factory function to create an LLM for a given agent
-            planner: LLM to use for planning steps (if not provided, a default planner will be used)
-            plan_type: "full" planning generates the full plan first, then executes. "iterative" plans the next step, and loops until success.
-            available_agents: List of agents available to tasks executed by this orchestrator
+            name: Name of the orchestrator workflow
+            planner: Pre-configured planner LLM to use for planning steps
+            available_agents: List of pre-configured agents available to this orchestrator
+            plan_type: "full" planning generates the full plan first, then executes. "iterative" plans next step and loops.
             context: Application context
         """
         # Initialize with orchestrator-specific defaults
         orchestrator_params = RequestParams(
             use_history=False,  # Orchestrator doesn't support history
             max_iterations=30,  # Higher default for complex tasks
-            maxTokens=8192,  # Higher default for planning TODO this will break some models - make configurable.
+            maxTokens=8192,  # Higher default for planning
             parallel_tool_calls=True,
         )
 
-        # If kwargs contains request_params, merge with our defaults but force use_history False
+        # If kwargs contains request_params, merge our defaults while preserving the model config
         if "request_params" in kwargs:
             base_params = kwargs["request_params"]
-            merged = base_params.model_copy()
-            merged.use_history = False  # Force this setting
+            # Create merged params starting with our defaults
+            merged = orchestrator_params.model_copy()
+            # Update with base params to get model config
+            if isinstance(base_params, dict):
+                merged = merged.model_copy(update=base_params)
+            else:
+                merged = merged.model_copy(update=base_params.model_dump())
+            # Force specific settings
+            merged.use_history = False
             kwargs["request_params"] = merged
         else:
             kwargs["request_params"] = orchestrator_params
 
         super().__init__(context=context, **kwargs)
 
-        self.llm_factory = llm_factory
-
-        # Create default planner with AgentConfig
-        request_params = self.get_request_params(kwargs.get("request_params"))
-        planner_config = AgentConfig(
-            name="LLM Orchestrator",
-            instruction="""
-            You are an expert planner. Given an objective task and a list of MCP servers (which are collections of tools)
-            or Agents (which are collections of servers), your job is to break down the objective into a series of steps,
-            which can be performed by LLMs with access to the servers or agents.
-            """,
-            servers=[],  # Planner doesn't need direct server access
-            default_request_params=request_params,
-            model=request_params.model if request_params else None,
-        )
-
-        self.planner = planner or llm_factory(agent=Agent(config=planner_config))
-
-        self.plan_type: Literal["full", "iterative"] = plan_type
+        self.planner = planner
+        self.plan_type = plan_type
         self.server_registry = self.context.server_registry
-        self.agents = {agent.name: agent for agent in available_agents or []}
+        self.agents = {agent.name: agent for agent in available_agents}
 
     async def generate(
         self,
@@ -155,25 +146,15 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
     ) -> ModelT:
         """Request a structured LLM generation and return the result as a Pydantic model."""
         params = self.get_request_params(request_params)
-
         result_str = await self.generate_str(message=message, request_params=params)
 
-        structured_config = AgentConfig(
-            name="Structured Output",
-            instruction="Produce a structured output given a message",
-            servers=[],  # No server access needed for structured output
-        )
-
-        llm = self.llm_factory(agent=Agent(config=structured_config))
-
-        structured_result = await llm.generate_structured(
+        # Use AugmentedLLM's structured output handling
+        return await super().generate_structured(
             message=result_str,
             response_model=response_model,
             request_params=params,
         )
 
-        return structured_result
-
     async def execute(
         self, objective: str, request_params: RequestParams | None = None
     ) -> PlanResult:
@@ -233,8 +214,6 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
                 plan_result.add_step_result(step_result)
 
-                plan_result.add_step_result(step_result)
-
             logger.debug(
                 f"Iteration {iterations}: Intermediate plan result:", data=plan_result
             )
@@ -251,70 +230,36 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         request_params: RequestParams | None = None,
     ) -> StepResult:
         """Execute a step's subtasks in parallel and synthesize results"""
-        params = self.get_request_params(request_params)
 
         step_result = StepResult(step=step, task_results=[])
         context = format_plan_result(previous_result)
 
-        # Prepare tasks and LLMs
-        task_llms = []
-        async with contextlib.AsyncExitStack() as stack:
-            for task in step.tasks:
-                agent = self.agents.get(task.agent)
-                if not agent:
-                    raise ValueError(f"No agent found matching {task.agent}")
-
-                if isinstance(agent, AugmentedLLM):
-                    llm = agent
-                else:
-                    # Use existing LLM if agent has one
-                    if hasattr(agent, "_llm") and agent._llm:
-                        llm = agent._llm
-                    else:
-                        # Only create new context if needed
-                        ctx_agent = await stack.enter_async_context(agent)
-                        # Create factory with agent's own configuration
-                        agent_factory = ModelFactory.create_factory(
-                            model_string=agent.config.model,
-                            request_params=agent.config.default_request_params,
-                        )
-                        llm = await ctx_agent.attach_llm(agent_factory)
-
-                task_llms.append((task, llm))
-
-            # Execute all tasks within the same context
-            futures = []
-            for task, llm in task_llms:
-                task_description = TASK_PROMPT_TEMPLATE.format(
-                    objective=previous_result.objective,
-                    task=task.description,
-                    context=context,
-                )
-                # Get the agent's config for task execution
-                agent = self.agents.get(task.agent)
-                task_params = (
-                    agent.config.default_request_params
-                    if hasattr(agent, "config")
-                    else params
-                )
-                futures.append(
-                    llm.generate_str(
-                        message=task_description, request_params=task_params
-                    )
-                )
+        # Execute tasks
+        futures = []
+        for task in step.tasks:
+            agent = self.agents.get(task.agent)
+            if not agent:
+                raise ValueError(f"No agent found matching {task.agent}")
+
+            task_description = TASK_PROMPT_TEMPLATE.format(
+                objective=previous_result.objective,
+                task=task.description,
+                context=context,
+            )
 
-            # Wait for all tasks, including any tool calls they make
-            results = await self.executor.execute(*futures)
+            # All agents should now be LLM-capable
+            futures.append(agent._llm.generate_str(message=task_description))
 
-            # Process results while contexts are still active
-            for (task, _), result in zip(task_llms, results):
-                step_result.add_task_result(
-                    TaskWithResult(**task.model_dump(), result=str(result))
-                )
+        # Wait for all tasks
+        results = await self.executor.execute(*futures)
 
-            # Format final result while contexts are still active
-            step_result.result = format_step_result(step_result)
+        # Process results
+        for task, result in zip(step.tasks, results):
+            step_result.add_task_result(
+                TaskWithResult(**task.model_dump(), result=str(result))
+            )
 
+        step_result.result = format_step_result(step_result)
         return step_result
 
     async def _get_full_plan(