agentic-team-orchestrator 0.2.0__tar.gz

agentic_team_orchestrator-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parth Bisht
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentic_team_orchestrator-0.2.0/MANIFEST.in

@@ -0,0 +1,7 @@
+# MANIFEST.in
+include README.md
+include LICENSE
+recursive-exclude * .env
+recursive-exclude * __pycache__
+recursive-exclude * *.pyc
+exclude .env

agentic_team_orchestrator-0.2.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: agentic-team-orchestrator
+Version: 0.2.0
+Summary: A JIT Agent Factory that manifests multi-agent teams using Agno, LangGraph, and CrewAI on the fly.
+Author-email: Parth Bisht <parth@example.com>
+Project-URL: Homepage, https://github.com/parthbisht/agentic-team-orchestrator
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: streamlit
+Requires-Dist: openai
+Requires-Dist: duckduckgo-search
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Requires-Dist: agno
+Requires-Dist: crewai
+Requires-Dist: langgraph
+Dynamic: license-file
+
+# 🚀 JIT Agentic Team Orchestrator
+
+**Understand. Manifest. Architect.**
+
+The `agentic-team-orchestrator` is a Meta-Agent platform that dynamically manifests specialized multi-agent teams on-the-fly based on a user mission.
+
+## 🌟 Key Features
+- **Dynamic Framework Selection**: Automatically picks the best engine (**Agno, LangGraph, CrewAI, AutoGen**) for your task.
+- **JIT Tool Generation**: Generates real, functional Python tools using `duckduckgo_search` instead of mock logic.
+- **Specialized Team Planner**: Designs Roles, Goals, and Workflows specifically for your mission.
+- **Wonderful UI Visualization**: A Streamlit-based dashboard to visualize agent roles, mission strategy, and generated code.
+
+## 🚀 Quick Start
+```bash
+pip install agentic-team-orchestrator
+streamlit run app.py
+```
+
+## 🛠️ Performance
+- Architect missions in seconds.
+- Manifest complete framework-based source codes instantly.
+- Toggle between functional automation and strategic planning.
+
+## 📜 License
+MIT

agentic_team_orchestrator-0.2.0/README.md

@@ -0,0 +1,25 @@
+# 🚀 JIT Agentic Team Orchestrator
+
+**Understand. Manifest. Architect.**
+
+The `agentic-team-orchestrator` is a Meta-Agent platform that dynamically manifests specialized multi-agent teams on-the-fly based on a user mission.
+
+## 🌟 Key Features
+- **Dynamic Framework Selection**: Automatically picks the best engine (**Agno, LangGraph, CrewAI, AutoGen**) for your task.
+- **JIT Tool Generation**: Generates real, functional Python tools using `duckduckgo_search` instead of mock logic.
+- **Specialized Team Planner**: Designs Roles, Goals, and Workflows specifically for your mission.
+- **Wonderful UI Visualization**: A Streamlit-based dashboard to visualize agent roles, mission strategy, and generated code.
+
+## 🚀 Quick Start
+```bash
+pip install agentic-team-orchestrator
+streamlit run app.py
+```
+
+## 🛠️ Performance
+- Architect missions in seconds.
+- Manifest complete framework-based source codes instantly.
+- Toggle between functional automation and strategic planning.
+
+## 📜 License
+MIT

agentic_team_orchestrator-0.2.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentic-team-orchestrator"
+version = "0.2.0"
+authors = [
+  { name="Parth Bisht", email="parth@example.com" },
+]
+description = "A JIT Agent Factory that manifests multi-agent teams using Agno, LangGraph, and CrewAI on the fly."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "streamlit",
+    "openai",
+    "duckduckgo-search",
+    "requests",
+    "python-dotenv",
+    "agno",
+    "crewai",
+    "langgraph"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/parthbisht/agentic-team-orchestrator"
+
+[project.scripts]
+agentic-factory = "agentic_team_orchestrator.app:main"

agentic_team_orchestrator-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator/app.py

@@ -0,0 +1,138 @@
+import streamlit as st
+import os
+from .controller import Controller
+from dotenv import load_dotenv
+
+# Load env
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="🚀 Multi-Agent Factory",
+    layout="wide"
+)
+
+# ---------- UI STYLES ----------
+st.markdown("""
+<style>
+.main { background-color: #0e0e0e; }
+.agent-card {
+    background-color: #1e1e2d;
+    border-radius: 12px;
+    padding: 20px;
+    border-left: 5px solid #3b82f6;
+    margin-bottom: 20px;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.4);
+}
+.task-step {
+    background-color: #2d2d3d;
+    border-radius: 8px;
+    padding: 15px;
+    margin-top: 10px;
+    border: 1px solid #444;
+}
+.mission-banner {
+    background: linear-gradient(90deg, #1e3a8a 0%, #3b82f6 100%);
+    padding: 20px;
+    border-radius: 10px;
+    color: white;
+}
+</style>
+""", unsafe_allow_html=True)
+
+# ---------- SESSION STATE ----------
+if "controller" not in st.session_state:
+    st.session_state.controller = None
+
+if "ui_schema" not in st.session_state:
+    st.session_state.ui_schema = []
+
+if "plan" not in st.session_state:
+    st.session_state.plan = {}
+
+# ---------- HEADER ----------
+st.title("🚀 JIT Multi-Agent Factory")
+st.caption("Architect specialized teams and watch them build tools and execute missions.")
+
+# ---------- SIDEBAR ----------
+st.sidebar.subheader("Configuration")
+api_key = st.sidebar.text_input(
+    "OpenAI API Key",
+    type="password",
+    value=os.getenv("OPENAI_API_KEY", "")
+)
+
+# ---------- INPUT ----------
+user_prompt = st.text_area(
+    "What mission should the factory architect?",
+    placeholder="e.g. Conduct a deep research on the current AI chip market and generate a summary report.",
+    height=120
+)
+
+# ---------- BUILD AGENT ----------
+if st.button("🏗️ Architect Mission"):
+    if not api_key:
+        st.error("❌ API key missing")
+        st.stop()
+
+    try:
+        st.session_state.controller = Controller(api_key)
+
+        with st.status("🏗️ Architecting Multi-Agent System...") as status:
+            st.write("Generating Team Mission and Roles...")
+            res = st.session_state.controller.build_agent(user_prompt)
+            st.session_state.plan = res
+            st.session_state.ui_schema = res["ui_schema"]
+            st.write("Developing JIT Tool Code for each agent...")
+            status.update(label="✅ Team Architected!", state="complete")
+
+    except Exception as e:
+        st.error(f"Error in architecture: {str(e)}")
+
+# ---------- RENDER MISSION ----------
+if st.session_state.plan:
+    st.markdown(f"""
+    <div class="mission-banner">
+        <h3>🚀 Automation Objective: {st.session_state.plan['mission']}</h3>
+        <p><b>Strategy:</b> {st.session_state.plan.get('execution_strategy', 'Standard Processing')}</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    tab1, tab2, tab3 = st.tabs(["👥 Agent Team", "🔄 Workflow", "💻 Generated Code"])
+
+    # ---------- TEAM TAB ----------
+    with tab1:
+        st.subheader("Specialized Agent Team")
+        cols = st.columns(len(st.session_state.plan["agents"]))
+        for i, agent in enumerate(st.session_state.plan["agents"]):
+            with cols[i]:
+                st.markdown(f"""
+                <div class="agent-card">
+                    <h4>{agent['name']}</h4>
+                    <p><small>{agent['role']}</small></p>
+                    <p><b>Goal:</b> {agent['goal']}</p>
+                    <p><b>Tools:</b> {', '.join(agent['tools'])}</p>
+                </div>
+                """, unsafe_allow_html=True)
+
+    # ---------- WORKFLOW TAB ----------
+    with tab2:
+        st.subheader("Multi-Step Task Execution Strategy")
+        for task in st.session_state.plan["tasks"]:
+            st.markdown(f"""
+            <div class="task-step">
+                <b>Step {task['step']}: {task['name']}</b><br>
+                Assigned Agent: <code>{task['agent']}</code><br>
+                <i>Description: {task['description']}</i><br>
+                Tools utilized: {', '.join(task.get('tools', []))}
+            </div>
+            """, unsafe_allow_html=True)
+
+    # ---------- CODE TAB ----------
+    with tab3:
+        st.subheader("🛠️ Component Source Code")
+        st.caption("This is the self-contained Python code for the JIT-generated tools.")
+        if "full_code" in st.session_state.plan:
+            st.code(st.session_state.plan["full_code"], language="python")
+        else:
+            st.info("Code not yet architected.")

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator/controller.py

@@ -0,0 +1,14 @@
+from .orchestrator import Orchestrator
+
+class Controller:
+    def __init__(self, api_key):
+        self.orch = Orchestrator(api_key)
+
+    def build_agent(self, prompt):
+        return self.orch.architect(prompt)
+
+    def run_agent(self, inputs):
+        return self.orch.execute(inputs)
+
+    def run_tool(self, tool_name, args):
+        return self.orch.execute_tool(tool_name, args)

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator/orchestrator.py

@@ -0,0 +1,132 @@
+import json
+import os
+import inspect
+from typing import Dict, Any, List, Optional
+from agno.agent import Agent
+from agno.tools.duckduckgo import DuckDuckGo
+from .planner import Planner
+
+class MCPToolDiscovery:
+    """Simulates an MCP Server that provides 'Best Practices' for agent tools."""
+    def get_tool_definitions(self, task_type: str) -> str:
+        """Returns the 'Best Practice' code pattern for a given task type."""
+        # This acts as an MCP Resource Provider
+        patterns = {
+            "search": "Use DDGS to find information. Return structured dictionaries.",
+            "compare": "Identify key metrics (price, features) and return a sorted JSON list.",
+            "automate": "Use requests to simulate interaction or fetch API data."
+        }
+        return patterns.get(task_type.lower(), "Write clean, self-contained Python functions.")
+
+class Orchestrator:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        # Ensure the key is available for the Agno Agents
+        os.environ["OPENAI_API_KEY"] = api_key
+        
+        # THE ARCHITECT: An autonomous agent instead of just a prompt.
+        self.architect_agent = Agent(
+            name="Meta-Architect",
+            role="Expert Systems Designer & Programmer",
+            description="You architect multi-agent systems. Use MCP discovery to find best practices before coding.",
+            tools=[MCPToolDiscovery().get_tool_definitions],
+            show_tool_calls=True,
+            markdown=True
+        )
+        self.planner = Planner(api_key)
+        self.tools: Dict[str, Any] = {}
+        self.ui_schema: List[Dict[str, Any]] = []
+
+    def architect(self, task: str) -> Dict[str, Any]:
+        """Architects the tools and UI using an autonomous reasoning loop."""
+        # Step 1: Design the Initial Strategy
+        plan_data = self.planner.create_plan(task)
+        
+        # Step 2: The Architect uses its own agentic loop to manifest the manifestation
+        # It discovers best practices (MCP) and then generates the JSON
+        agent_mission = f"""
+        Mission: {plan_data.get('mission')}
+        Framework: {plan_data.get('framework')}
+        Architecture Strategy: {plan_data.get('execution_strategy')}
+        
+        Your task is to manifest the tools and the full Python source code for this system.
+        Manifest it as a valid JSON object with: 'tools', 'full_code', and 'ui_schema'.
+        """
+        
+        # Autonomous execution instead of static prompt
+        res = self.architect_agent.run(agent_mission)
+        
+        # Extract JSON from agentic response (Agent returns response.content)
+        content = res.content
+        # Basic JSON extraction logic
+        json_start = content.find('{')
+        json_end = content.rfind('}') + 1
+        data = json.loads(content[json_start:json_end])
+        
+        self.ui_schema = data["ui_schema"]
+        self.full_source_code = data.get("full_code", "# No code generated")
+
+        # Register tools for local execution
+        for t in data["tools"]:
+            local_env = {}
+            try:
+                exec(t["code"], local_env)
+                self.tools[t["name"]] = local_env[t["name"]]
+            except Exception as e:
+                print(f"Error compiling tool {t['name']}: {e}")
+
+        return {
+            "mission": plan_data.get("mission"),
+            "agents": plan_data.get("agents"),
+            "tasks": plan_data.get("tasks"),
+            "ui_schema": self.ui_schema,
+            "full_code": self.full_source_code,
+            "framework": plan_data.get("framework")
+        }
+
+    def execute(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Executes the specialized agents sequentially through the tasks."""
+        results = {}
+        context = inputs.copy()  # Shared memory for agents
+
+        # Sort tasks by step
+        sorted_tasks = sorted(self.tasks, key=lambda x: x.get("step", 0))
+
+        for task in sorted_tasks:
+            # Each task uses one or more tools owned by its agent
+            step_tools = task.get("tools", [])
+            task_results = {}
+            
+            for tool_name in step_tools:
+                func = self.tools.get(tool_name)
+                if not func:
+                    continue
+                
+                # Automatically extract valid arguments from context
+                sig = inspect.signature(func)
+                valid_args = {k: v for k, v in context.items() if k in sig.parameters}
+                
+                try:
+                    output = func(**valid_args)
+                    task_results[tool_name] = output
+                    # Feed output back into context for next agent
+                    if isinstance(output, dict):
+                        context.update(output)
+                    else:
+                        context[f"{tool_name}_output"] = str(output)
+                except Exception as e:
+                    task_results[tool_name] = {"error": str(e)}
+
+            results[task["name"]] = task_results
+
+        return results
+
+    def execute_tool(self, tool_name: str, args: Dict[str, Any]) -> Any:
+        """Utility to call a single tool."""
+        func = self.tools.get(tool_name)
+        if not func:
+            return f"Tool {tool_name} not found"
+        
+        sig = inspect.signature(func)
+        valid_args = {k: v for k, v in args.items() if k in sig.parameters}
+        return func(**valid_args)

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator/planner.py

@@ -0,0 +1,54 @@
+import json
+import os
+from typing import Dict, Any, List
+from agno.agent import Agent
+
+class MCPMissionDiscovery:
+    """Simulates an MCP Server that provides 'Strategic Blueprints' for missions."""
+    def get_mission_patterns(self, mission_type: str) -> str:
+        """Returns the 'Strategic Blueprint' for a given mission type."""
+        blueprints = {
+            "flight": "Step 1: Discover sites. Step 2: Map parameters. Step 3: Compare results.",
+            "research": "Step 1: Scrape data. Step 2: Extract findings. Step 3: Summarize report.",
+            "automation": "Step 1: Identify triggers. Step 2: Run loop. Step 3: Format output."
+        }
+        return blueprints.get(mission_type.lower(), "Design a robust, multi-agent operational flow.")
+
+class Planner:
+    def __init__(self, api_key: str):
+        # Ensure key is available for the Strategy Architect
+        os.environ["OPENAI_API_KEY"] = api_key
+
+        # THE STRATEGY ARCHITECT: A highly technical mission designer.
+        self.strategy_agent = Agent(
+            name="Strategy-Architect",
+            role="Expert Multi-Agent Workflow Architect",
+            description="""
+            You design deep, functional automation blueprints. 
+            DO NOT provide generic or short descriptions.
+            Each task's 'description' must technically detail how data is being transformed and what logic is applied. 
+            Tools names must be precise and functional (e.g. 'mmt_expedia_search_aggregator').
+            Always aim for production-grade technical detail.
+            """,
+            tools=[MCPMissionDiscovery().get_mission_patterns],
+            markdown=True
+        )
+
+    def create_plan(self, task: str) -> Dict[str, Any]:
+        """Designs a structured multi-agent configuration using an agentic loop."""
+        
+        agent_mission = f"""
+        Objective: {task}
+        
+        Design a detailed mission plan.
+        Output MUST be a valid JSON with: 'mission', 'framework', 'execution_strategy', 'agents', and 'tasks'.
+        """
+
+        # Autonomous execution
+        res = self.strategy_agent.run(agent_mission)
+        
+        # Extract JSON from agentic response
+        content = res.content
+        json_start = content.find('{')
+        json_end = content.rfind('}') + 1
+        return json.loads(content[json_start:json_end])

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: agentic-team-orchestrator
+Version: 0.2.0
+Summary: A JIT Agent Factory that manifests multi-agent teams using Agno, LangGraph, and CrewAI on the fly.
+Author-email: Parth Bisht <parth@example.com>
+Project-URL: Homepage, https://github.com/parthbisht/agentic-team-orchestrator
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: streamlit
+Requires-Dist: openai
+Requires-Dist: duckduckgo-search
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Requires-Dist: agno
+Requires-Dist: crewai
+Requires-Dist: langgraph
+Dynamic: license-file
+
+# 🚀 JIT Agentic Team Orchestrator
+
+**Understand. Manifest. Architect.**
+
+The `agentic-team-orchestrator` is a Meta-Agent platform that dynamically manifests specialized multi-agent teams on-the-fly based on a user mission.
+
+## 🌟 Key Features
+- **Dynamic Framework Selection**: Automatically picks the best engine (**Agno, LangGraph, CrewAI, AutoGen**) for your task.
+- **JIT Tool Generation**: Generates real, functional Python tools using `duckduckgo_search` instead of mock logic.
+- **Specialized Team Planner**: Designs Roles, Goals, and Workflows specifically for your mission.
+- **Wonderful UI Visualization**: A Streamlit-based dashboard to visualize agent roles, mission strategy, and generated code.
+
+## 🚀 Quick Start
+```bash
+pip install agentic-team-orchestrator
+streamlit run app.py
+```
+
+## 🛠️ Performance
+- Architect missions in seconds.
+- Manifest complete framework-based source codes instantly.
+- Toggle between functional automation and strategic planning.
+
+## 📜 License
+MIT

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/agentic_team_orchestrator/__init__.py
+src/agentic_team_orchestrator/app.py
+src/agentic_team_orchestrator/controller.py
+src/agentic_team_orchestrator/orchestrator.py
+src/agentic_team_orchestrator/planner.py
+src/agentic_team_orchestrator.egg-info/PKG-INFO
+src/agentic_team_orchestrator.egg-info/SOURCES.txt
+src/agentic_team_orchestrator.egg-info/dependency_links.txt
+src/agentic_team_orchestrator.egg-info/entry_points.txt
+src/agentic_team_orchestrator.egg-info/requires.txt
+src/agentic_team_orchestrator.egg-info/top_level.txt

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentic-factory = agentic_team_orchestrator.app:main

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator.egg-info/requires.txt

@@ -0,0 +1,8 @@
+streamlit
+openai
+duckduckgo-search
+requests
+python-dotenv
+agno
+crewai
+langgraph

agentic_team_orchestrator-0.2.0/src/agentic_team_orchestrator.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentic_team_orchestrator