fast-agent-mcp 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

{fast_agent_mcp-0.0.8.dist-info → fast_agent_mcp-0.0.9.dist-info}/METADATA

@@ -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.dist-info → fast_agent_mcp-0.0.9.dist-info}/RECORD

@@ -13,12 +13,12 @@ mcp_agent/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/cli/__main__.py,sha256=bhxe66GYqy0q78OQhi7dkuubY1Tn0bQL6hU5Nn47E34,73
 mcp_agent/cli/main.py,sha256=wyOvUg0BihD1NpoiFcIaOruevgaHxs1-Xy_bnwb1Ik4,2449
 mcp_agent/cli/terminal.py,sha256=5fqrKlJvIpKEuvpvZ653OueQSYFFktBEbosjr2ucMUc,1026
-mcp_agent/cli/commands/bootstrap.py,sha256=mVng2bZPKfVEULrOPI7sQQaENAJwU-3SsGZb10mbu6Q,10614
+mcp_agent/cli/commands/bootstrap.py,sha256=5OAxs1IsWarFNX1IoTRbVyjMqktxJ3pweM3LwGOVAhk,10768
 mcp_agent/cli/commands/config.py,sha256=32YTS5jmsYAs9QzAhjkG70_daAHqOemf4XbZBBSMz6g,204
 mcp_agent/cli/commands/setup.py,sha256=Km4-EFJljjMU5XjsSa-srg_7lbPuH5e40sx4lQDkia4,6198
 mcp_agent/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/core/exceptions.py,sha256=xDdhYh83ni3t0NiXQTEL0_Yyx0qQxBPQL1gSwRToeaw,1469
-mcp_agent/core/fastagent.py,sha256=WuT0B9XpGM7XowJivNkRcIm-0BthlObVtoNwcBaNKCA,40641
+mcp_agent/core/fastagent.py,sha256=THy6lDg3CjgF_nMKq8GtWkFT03r6-8VKFFhjjECx6aE,42699
 mcp_agent/core/server_validation.py,sha256=_59cn16nNT4HGPwg19HgxMtHK4MsdWYDUw_CuL-5xek,1696
 mcp_agent/eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,15 +47,16 @@ mcp_agent/mcp/mcp_agent_server.py,sha256=xP09HZTeguJi4Fq0p3fjLBP55uSYe5AdqM90xCg
 mcp_agent/mcp/mcp_aggregator.py,sha256=SQNErk20jTT_5cHTQ9zQBYEsAedd6QEweQj-YSzkdOo,14602
 mcp_agent/mcp/mcp_connection_manager.py,sha256=tdz2B2BxmO2gBDPe4r6eEnUp4QpwD0p0-ag5J_hle-w,11750
 mcp_agent/mcp/stdio.py,sha256=tW075R5rQ-UlflXWFKIFDgCbWbuhKqxhiYolWvyEkFs,3985
-mcp_agent/resources/examples/data-analysis/analysis.py,sha256=LrfbuK68JqcB9Y21NMedJ8RiEVU5Kr6jOIRLGmwz524,1379
-mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=VwoXyaxAuLNUm7dtRj5rTxeFDSM_wRhhX_HZunb8jUI,422
+mcp_agent/resources/examples/data-analysis/analysis.py,sha256=Sp-umPPfwVjG3yNrHdQA6blGtG6jc5of1e_0oS4njYc,1379
+mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=eTKGbjnTHhDTeNRPQvG_fr9OQpEZ5Y9v7X2NyCj0V70,530
 mcp_agent/resources/examples/data-analysis/mount-point/WA_Fn-UseC_-HR-Employee-Attrition.csv,sha256=pcMeOL1_r8m8MziE6xgbBrQbjl5Ijo98yycZn7O-dlk,227977
 mcp_agent/resources/examples/mcp_researcher/researcher-eval.py,sha256=NI1vujVuLeTrcF8dM_ipZZ3Tg-1AL35CaltmuzxWrU4,1807
 mcp_agent/resources/examples/mcp_researcher/researcher.py,sha256=jPRafm7jbpHKkX_dQiYGG3Sw-e1Dm86q-JZT-WZDhM0,1425
 mcp_agent/resources/examples/workflows/chaining.py,sha256=o9vf45BtJP6PT7kCYfIyNTcJrVGnMeKCUD37vI0cepw,770
 mcp_agent/resources/examples/workflows/evaluator.py,sha256=ByILFY7PsA8UXtmNa4YtLIGSsnVfZVjKlHGH9G0ie2I,3069
-mcp_agent/resources/examples/workflows/human_input.py,sha256=RlUch5A8N9pb3REusiIAZKfAGTxWWE82s1Npmkfbg1Y,625
-mcp_agent/resources/examples/workflows/orchestrator.py,sha256=pt6HTyJl5r5zR6FUICi05-Eaulyh_W-PAfh9XCbuuRc,2986
+mcp_agent/resources/examples/workflows/fastagent.config.yaml,sha256=s8USBUpEymJbOLVp-NiFuo86h4sCxL9TB5H-Ub8i0hQ,234
+mcp_agent/resources/examples/workflows/human_input.py,sha256=c8cBdLEPbaMXddFwsfN3Z7RFs5PZXsdrjANfvq1VTPM,605
+mcp_agent/resources/examples/workflows/orchestrator.py,sha256=LaV5rzBy6NvnlFd91f96bKFrle6voxDA1TFa8hVxQ9Y,2550
 mcp_agent/resources/examples/workflows/parallel.py,sha256=cNYcIcsdo0-KK-S7KEPCc11aWELeVlQJdJ2LIC9xgDs,3090
 mcp_agent/resources/examples/workflows/router.py,sha256=XT_ewCrxPxdUTMCYQGw34qZQ3GGu8TYY_v5Lige8By4,1707
 mcp_agent/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -77,12 +78,12 @@ mcp_agent/workflows/intent_classifier/intent_classifier_llm_anthropic.py,sha256=
 mcp_agent/workflows/intent_classifier/intent_classifier_llm_openai.py,sha256=zj76WlTYnSCYjBQ_IDi5vFBQGmNwYaoUq1rT730sY98,1940
 mcp_agent/workflows/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/workflows/llm/augmented_llm.py,sha256=o5Vdn1sAgVBhmetilbiYJuVz5BAtEhNcwGMEBGNzU_A,22960
-mcp_agent/workflows/llm/augmented_llm_anthropic.py,sha256=jowYvWBdVspxQhcvZt14iL_1kEZK2t4f6Wzgn_8zLaY,21048
+mcp_agent/workflows/llm/augmented_llm_anthropic.py,sha256=rcaFn4ZhxJgBuTsRCKCcCx4U8UYqAhJNh3EK5M5hgew,21118
 mcp_agent/workflows/llm/augmented_llm_openai.py,sha256=RqsbX0Fc5By1AvQ2N85hxzz0d84mVwuPggslxwqSJVM,24190
 mcp_agent/workflows/llm/llm_selector.py,sha256=G7pIybuBDwtmyxUDov_QrNYH2FoI0qFRu2JfoxWUF5Y,11045
 mcp_agent/workflows/llm/model_factory.py,sha256=cAjG8UxzUC_wcB6mPaMfEhwnGnVS4-IOmOXDabO1_0g,6119
 mcp_agent/workflows/orchestrator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/workflows/orchestrator/orchestrator.py,sha256=tSRMCRFT_gAQApRRiXXznCbk_x11o86oi5LfKLnXzdk,15146
+mcp_agent/workflows/orchestrator/orchestrator.py,sha256=BMGToWE-C2WiL74U5s0oT5wKoHWWxhWZ_lRfHm-8ryg,12494
 mcp_agent/workflows/orchestrator/orchestrator_models.py,sha256=UWn7_HFLcqFGlcjZ1Rn2SYQfm5k9seS6QJN_FRST5Kc,4513
 mcp_agent/workflows/orchestrator/orchestrator_prompts.py,sha256=AQ9-1WyMIl6l36yAMh1dtJ6Vhi1jPrvGXF2CNNAtlpA,3946
 mcp_agent/workflows/parallel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -99,8 +100,8 @@ mcp_agent/workflows/swarm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 mcp_agent/workflows/swarm/swarm.py,sha256=-lAIeSWDqbGHGRPTvjiP9nIKWvxxy9DAojl9yQzO1Pw,11050
 mcp_agent/workflows/swarm/swarm_anthropic.py,sha256=pW8zFx5baUWGd5Vw3nIDF2oVOOGNorij4qvGJKdYPcs,1624
 mcp_agent/workflows/swarm/swarm_openai.py,sha256=wfteywvAGkT5bLmIxX_StHJq8144whYmCRnJASAjOes,1596
-fast_agent_mcp-0.0.8.dist-info/METADATA,sha256=tPypBpbGkwNNIRHnJJF7Nn68O1bJHIdV3WFvVup3xyI,15914
-fast_agent_mcp-0.0.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.0.8.dist-info/entry_points.txt,sha256=2IXtSmDK9XjWN__RWuRIJTgWyW17wJnJ_h-pb0pZAxo,174
-fast_agent_mcp-0.0.8.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.0.8.dist-info/RECORD,,
+fast_agent_mcp-0.0.9.dist-info/METADATA,sha256=KBbUbJ7Sx0c9ZvVd9j2zJCdgr1BIDUwvfqN6nAzMjew,15966
+fast_agent_mcp-0.0.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.0.9.dist-info/entry_points.txt,sha256=2IXtSmDK9XjWN__RWuRIJTgWyW17wJnJ_h-pb0pZAxo,174
+fast_agent_mcp-0.0.9.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.0.9.dist-info/RECORD,,

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]")
 

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)

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. 

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:

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","."]

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:

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",
 )

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)

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(