Reusable Execution Strategies for LLM Workflows

# Illustrative sketch (not from the paper)
import torch

# Placeholder producer and verifier models
class ProducerModel(torch.nn.Module):
    def forward(self, task, context=None):
        # Generate a tentative execution trajectory
        return {"steps": ["action1", "action2"], "context": context}

class VerifierModel(torch.nn.Module):
    def forward(self, trajectory):
        # Return True if trajectory satisfies all constraints
        return len(trajectory["steps"]) > 0

producer = ProducerModel()
verifier = VerifierModel()

def evolve_until_verified(task, max_iters=5):
    """Iteratively refine execution until verifier approves."""
    context = None
    for _ in range(max_iters):
        traj = producer(task, context)          # producer generates trajectory
        if verifier(traj):                     # verifier checks constraints
            return traj                        # verified trajectory
        # feedback: incorporate verifier hint (placeholder)
        context = {"feedback": "refine"}
    raise RuntimeError("Failed to obtain verified trajectory")

def extract_gene(trajectory):
    """Condense critical info from a verified trajectory into a Gene dict."""
    # Here we simply keep the steps; real Gene would be more structured
    return {"gene_steps": trajectory["steps"]}

def consumer_one_shot(task, gene):
    """Consumer model uses Gene to perform one-shot execution."""
    # In practice the consumer would be a separate LLM; we mock it
    return {"task": task, "executed": gene["gene_steps"]}

# Example workflow
task_example = "solve_complex_problem"
verified_traj = evolve_until_verified(task_example)
 gene = extract_gene(verified_traj)
result = consumer_one_shot(task_example, gene)
print(result)

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder import for illustration

// Mock producer and verifier objects
class ProducerModel {
  forward(task, context = null) {
    // Generate a tentative execution trajectory
    return { steps: ['action1', 'action2'], context };
  }
}

class VerifierModel {
  forward(trajectory) {
    // Return true if trajectory satisfies constraints
    return trajectory.steps.length > 0;
  }
}

const producer = new ProducerModel();
const verifier = new VerifierModel();

function evolveUntilVerified(task, maxIters = 5) {
  // Iteratively refine execution until verifier approves
  let context = null;
  for (let i = 0; i < maxIters; i++) {
    const traj = producer.forward(task, context);
    if (verifier.forward(traj)) {
      return traj; // verified trajectory
    }
    // feedback: incorporate verifier hint (placeholder)
    context = { feedback: 'refine' };
  }
  throw new Error('Failed to obtain verified trajectory');
}

function extractGene(trajectory) {
  // Condense critical info from a verified trajectory into a Gene object
  return { geneSteps: trajectory.steps };
}

function consumerOneShot(task, gene) {
  // Consumer model uses Gene to perform one-shot execution
  return { task, executed: gene.geneSteps };
}

// Example workflow
const taskExample = 'solve_complex_problem';
const verifiedTraj = evolveUntilVerified(taskExample);
const gene = extractGene(verifiedTraj);
const result = consumerOneShot(taskExample, gene);
console.log(result);