Automating Agent Skill Creation From Data

# Illustrative sketch (not from the paper)
import torch

# Step 1: Implicit Requirement Discovery
def discover_requirements(task_brief, open_world_corpus):
    # contrastive evidence acquisition (placeholder)
    evidence = retrieve_contrastive_evidence(task_brief, open_world_corpus)
    # convert missing dimensions into research questions
    questions = [f"What is the {dim}?" for dim in infer_missing_dims(task_brief, evidence)]
    return questions

# Step 2: Grounded Procedure Admission
def admit_procedures(evidence, decision_point):
    candidates = extract_procedures(evidence, decision_point)
    admitted = []
    for proc in candidates:
        scope = evaluate_scope(proc, evidence)
        if scope == "general":
            admitted.append({"type": "instruction", "content": proc})
        elif scope == "scoped":
            admitted.append({"type": "example", "content": proc})
        # else exclude
    return admitted

# Step 3: Skill Package Compilation
def compile_skill_package(admitted, skill_name):
    root = f"./skills/{skill_name}"
    torch.save(admitted, f"{root}/procedure.pt")  # using torch for serialization
    # create a simple manifest following a corpus‑derived grammar
    manifest = {"skill": skill_name, "components": [p["type"] for p in admitted]}
    torch.save(manifest, f"{root}/manifest.pt")
    return root

// Illustrative sketch (not from the paper)
const fs = require('fs');

// Step 1: Implicit Requirement Discovery
function discoverRequirements(taskBrief, corpus) {
  const evidence = retrieveContrastiveEvidence(taskBrief, corpus); // placeholder
  const missing = inferMissingDims(taskBrief, evidence);
  return missing.map(dim => `What is the ${dim}?`);
}

// Step 2: Grounded Procedure Admission
function admitProcedures(evidence, decisionPoint) {
  const candidates = extractProcedures(evidence, decisionPoint);
  const admitted = [];
  for (const proc of candidates) {
    const scope = evaluateScope(proc, evidence);
    if (scope === 'general') admitted.push({type: 'instruction', content: proc});
    else if (scope === 'scoped') admitted.push({type: 'example', content: proc});
    // otherwise exclude
  }
  return admitted;
}

// Step 3: Skill Package Compilation
function compileSkillPackage(admitted, skillName) {
  const root = `./skills/${skillName}`;
  if (!fs.existsSync(root)) fs.mkdirSync(root, {recursive: true});
  fs.writeFileSync(`${root}/procedure.json`, JSON.stringify(admitted, null, 2));
  const manifest = {skill: skillName, components: admitted.map(p => p.type)};
  fs.writeFileSync(`${root}/manifest.json`, JSON.stringify(manifest, null, 2));
  return root;
}