The Definitive Guide to Meta-Prompting:
Architectures, Implementation, and Agentic Workflows

class MetaPromptingSystem:
    def __init__(self, client, model="gpt-4o"):
        self.client = client
        self.model = model
        self.conductor_history =

    def call_llm(self, messages: List, temperature=0.0) -> str:
        """Helper to call the LLM API."""
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=messages,
                temperature=temperature
            )
            return response.choices.message.content
        except Exception as e:
            return f"System Error: {str(e)}"

    def extract_tags(self, text: str, tag: str) -> Optional[str]:
        """Extracts content between XML-style tags."""
        pattern = f"<{tag}>(.*?)</{tag}>"
        match = re.search(pattern, text, re.DOTALL)
        return match.group(1).strip() if match else None

    def run(self, user_query: str, max_turns=10):
        # 1. Initialize Conductor
        system_prompt = """"""
        self.conductor_history = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_query}
        ]

        print(f"--- Meta-Prompting Started: {user_query} ---")
        
        for turn in range(max_turns):
            # 2. Conductor Deliberates
            print(f"\n Conductor is thinking...")
            conductor_response = self.call_llm(self.conductor_history)
            print(f"[Conductor]: {conductor_response[:200]}...") # Print preview
            
            # 3. Check for Final Answer
            final_answer = self.extract_tags(conductor_response, "final_answer")
            if final_answer:
                return final_answer

            # 4. Check for Expert Delegation
            expert_name = self.extract_tags(conductor_response, "expert_name")
            instruction = self.extract_tags(conductor_response, "instruction")

            if expert_name and instruction:
                print(f"   >>> Delegating to [{expert_name}]...")
                
                # 5. The "Fresh Eyes" Execution
                # We create a NEW history for the expert. 
                # They do NOT see the conductor's history.
                expert_messages =
                
                expert_output = self.call_llm(expert_messages)
                print(f"   <<< Expert Output Received ({len(expert_output)} chars)")

                # 6. Feed Expert Output back to Conductor
                # We append the conductor's thought process AND the expert's result
                self.conductor_history.append({"role": "assistant", "content": conductor_response})
                self.conductor_history.append({
                    "role": "user", 
                    "content": f"Output from {expert_name}: {expert_output}. Proceed with the next step or finalize."
                })
            else:
                # If no tags found but no final answer, push the model to continue
                self.conductor_history.append({"role": "assistant", "content": conductor_response})
                self.conductor_history.append({
                    "role": "user", 
                    "content": "You provided no expert instructions and no final answer. Please continue."
                })

        return "Error: Maximum turns reached without final answer."

# Example Usage
# system = MetaPromptingSystem(client)
# result = system.run("Solve the 'Game of 24' for numbers 4, 7, 8, 8")
# print(result)