Standardizing Data Generation for AI Agents

# Illustrative sketch (not from the paper)
import torch
from typing import Any, Dict, Optional

# Factorized data object (E, q, τ, v)
class AgenticSample:
    def __init__(self, env_spec: Dict, task_signal: str, trajectory: Any, verifier: Optional[callable] = None):
        self.E = env_spec          # environment specification
        self.q = task_signal       # task description / signal
        self.tau = trajectory      # interaction realization
        self.v = verifier          # optional verifier

# Simple forward generation: env → task → trajectory

def forward_generate(env_spec):
    task = synthesize_task(env_spec)               # task signal from env
    traj = simulate_trajectory(env_spec, task)     # interaction rollout
    return AgenticSample(env_spec, task, traj)

# Placeholder for task synthesis (could use ToolLLM / APIGen style)
def synthesize_task(env_spec):
    return f"Perform action in {env_spec.get('name', 'unknown')}"

# Placeholder for trajectory simulation (could be executable API call)
def simulate_trajectory(env_spec, task):
    return {"steps": [task, "result"]}

# Layered verification: rule, model, human (illustrative only)

def verify(sample: AgenticSample):
    if not rule_check(sample):
        return False
    if not model_check(sample):
        return False
    if not human_check(sample):
        return False
    return True

def rule_check(sample):
    # simple structural rule: env must have a name
    return "name" in sample.E

def model_check(sample):
    # mock model verifier returning a confidence tensor
    confidence = torch.tensor(0.9)
    return confidence.item() > 0.8

def human_check(sample):
    # placeholder for human-in-the-loop approval
    return True

# Complexity calibration relative to a learner model (using a dummy torch net)
class LearnerNet(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = torch.nn.Linear(10, 1)
    def forward(self, x):
        return self.fc(x)

learner = LearnerNet()

def compute_complexity(sample: AgenticSample):
    # encode sample into a fixed-size vector (mocked as zeros)
    vec = torch.zeros(10)
    difficulty = learner(vec).item()
    return difficulty

# Diversity balancing (very simplified): keep a set of seen signatures
seen_signatures = set()

def is_diverse(sample: AgenticSample):
    sig = hash((frozenset(sample.E.items()), sample.q))
    if sig in seen_signatures:
        return False
    seen_signatures.add(sig)
    return True

# Main generation loop illustrating ACE constraints

def generate_ace_dataset(num_samples):
    dataset = []
    while len(dataset) < num_samples:
        env = {"name": f"Env{len(dataset)}"}
        sample = forward_generate(env)
        if not verify(sample):
            continue  # Accuracy check failed
        if compute_complexity(sample) > 0.5:  # placeholder threshold for learner
            continue  # Too complex for current learner
        if not is_diverse(sample):
            continue  # Diversity violation
        dataset.append(sample)
    return dataset

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

// Factorized data object (E, q, τ, v)
class AgenticSample {
  constructor(envSpec, taskSignal, trajectory, verifier = null) {
    this.E = envSpec;      // environment specification
    this.q = taskSignal;   // task description / signal
    this.tau = trajectory; // interaction realization
    this.v = verifier;     // optional verifier
  }
}

// Forward generation: env → task → trajectory
function forwardGenerate(envSpec) {
  const task = synthesizeTask(envSpec);
  const traj = simulateTrajectory(envSpec, task);
  return new AgenticSample(envSpec, task, traj);
}

function synthesizeTask(envSpec) {
  return `Perform action in ${envSpec.name || 'unknown'}`;
}

function simulateTrajectory(envSpec, task) {
  return { steps: [task, 'result'] };
}

// Layered verification (rule, model, human)
function verify(sample) {
  if (!ruleCheck(sample)) return false;
  if (!modelCheck(sample)) return false;
  if (!humanCheck(sample)) return false;
  return true;
}

function ruleCheck(sample) {
  return !!sample.E.name; // env must have a name
}

function modelCheck(sample) {
  const confidence = torch.tensor(0.9);
  return confidence.item() > 0.8;
}

function humanCheck(sample) {
  return true; // placeholder for human approval
}

// Complexity calibration relative to a learner model (mock net)
class LearnerNet {
  forward(x) { return x.mean(); } // dummy operation
}
const learner = new LearnerNet();

function computeComplexity(sample) {
  const vec = torch.zeros([10]); // mock encoding
  const difficulty = learner.forward(vec);
  return difficulty.item();
}

// Diversity balancing (simple signature set)
const seenSignatures = new Set();
function isDiverse(sample) {
  const sig = JSON.stringify({ env: sample.E, task: sample.q });
  if (seenSignatures.has(sig)) return false;
  seenSignatures.add(sig);
  return true;
}

// Main generation loop respecting ACE constraints
function generateAceDataset(numSamples) {
  const dataset = [];
  while (dataset.length < numSamples) {
    const env = { name: `Env${dataset.length}` };
    const sample = forwardGenerate(env);
    if (!verify(sample)) continue; // Accuracy
    if (computeComplexity(sample) > 0.5) continue; // Complexity threshold
    if (!isDiverse(sample)) continue; // Diversity
    dataset.push(sample);
  }
  return dataset;
}