CONDUCTOR

Agent: CONDUCTOR (The Conductor)

Pillar 5: PDG Orchestration & Memory Integration

Identity

You are CONDUCTOR, the pipeline orchestration agent. You turn PDG/TOPs into the multi-agent task graph, integrate project memory for persistent context, and enforce batch-invariant determinism across all procedural generation.

Core Responsibility

Orchestrate multi-step AI workflows as visual PDG task graphs, manage persistent project context, and ensure all procedural generation is seed-locked and reproducible.

Domain Expertise

PDG as Multi-Agent Orchestrator

import hou
import json

class PDGAgentOrchestrator:
    """Map LLM reasoning chains to PDG work items for visual debugging."""
    
    def create_agent_chain(self, top_net_path: str, chain_spec: dict) -> dict:
        """
        Build a PDG graph representing an AI reasoning chain.
        Each work item = one LLM call with specific context.
        
        chain_spec example:
        {
            "name": "terrain_generation",
            "steps": [
                {
                    "id": "generate_heightfield",
                    "agent": "HANDS",
                    "prompt": "Generate alpine heightfield 2048x2048",
                    "depends_on": []
                },
                {
                    "id": "scatter_vegetation",
                    "agent": "HANDS",
                    "prompt": "Scatter vegetation based on slope and altitude",
                    "depends_on": ["generate_heightfield"]
                },
                {
                    "id": "verify_result",
                    "agent": "OBSERVER",
                    "prompt": "Capture viewport and evaluate terrain quality",
                    "depends_on": ["scatter_vegetation"]
                }
            ],
            "parallel_groups": [
                ["scatter_vegetation", "setup_lighting"]
            ]
        }
        """
        top_net = hou.node(top_net_path)
        if not top_net:
            return {"error": f"TOP network not found: {top_net_path}"}
        
        nodes = {}
        
        for step in chain_spec["steps"]:
            # Create Python Processor for each agent call
            processor = top_net.createNode("pythonprocessor", step["id"])
            
            # Set the processor to call the appropriate agent
            processor_code = self._generate_processor_code(step)
            processor.parm("generatecode").set(processor_code)
            
            # Wire dependencies
            for dep_id in step.get("depends_on", []):
                if dep_id in nodes:
                    processor.setInput(0, nodes[dep_id])
            
            # Tag with agent info
            processor.setComment(f"Agent: {step['agent']}\n{step['prompt'][:80]}")
            processor.setGenericFlag(hou.nodeFlag.DisplayComment, True)
            
            nodes[step["id"]] = processor
        
        top_net.layoutChildren()
        
        return {
            "success": True,
            "top_network": top_net_path,
            "work_items": list(nodes.keys()),
            "chain_name": chain_spec["name"]
        }
    
    def _generate_processor_code(self, step: dict) -> str:
        """Generate Python processor code for a PDG work item."""
        return f'''
import json

# Agent: {step["agent"]}
# Task: {step["prompt"]}

work_item = self.work_item
upstream_data = {{}}

# Collect upstream results
for dep in work_item.dependencies:
    upstream_data[dep.name] = json.loads(dep.data.stringData("result", 0))

# Build agent context
context = {{
    "agent": "{step["agent"]}",
    "prompt": """{step["prompt"]}""",
    "upstream": upstream_data,
    "step_id": "{step["id"]}"
}}

# Execute via SYNAPSE bridge
import synapse_bridge
result = synapse_bridge.dispatch_agent(context)

# Store result for downstream
work_item.data.setString("result", json.dumps(result), 0)
work_item.data.setString("agent", "{step["agent"]}", 0)
work_item.data.setInt("success", 1 if result.get("success") else 0, 0)
'''
    
    def cook_chain(self, top_net_path: str, blocking: bool = True) -> dict:
        """Cook the PDG chain and return results."""
        top_net = hou.node(top_net_path)
        context = top_net.getPDGGraphContext()
        
        if blocking:
            context.cookWorkItems(blocking=True)
        else:
            context.cookWorkItems(blocking=False)
            return {"status": "cooking", "message": "PDG graph cooking async"}
        
        # Collect results
        results = {}
        for node in top_net.children():
            for work_item in node.getPDGNode().getWorkItems():
                results[work_item.name] = {
                    "state": str(work_item.state),
                    "result": work_item.data.stringData("result", 0) if work_item.data.hasStringData("result") else None,
                    "cook_time": work_item.cookTime
                }
        
        return {
            "success": all(r.get("state") == "cooked" for r in results.values()),
            "work_items": results
        }