Honey Tool Factory · Controlled tool generation

# Core capabilities

# 1. Pattern Extraction

Extract recurring operation patterns from Agent run trajectories. The factory analyzes Experiment traces from Agent Runtime, identifying high-frequency sequences (e.g., iPL.local_swap → iSTA.incremental → evaluate_hpwl appearing 12 times). Each pattern includes I/O types, pre/post conditions, typical success rate, and typical runtime.

# 2. Tool Generation

Solidify patterns into typed tool contracts. The factory auto-generates: tool name + description (for LLM understanding), typed request/result schema (JSON Schema), internal adapter (maps contract to EDA tool call sequences), error taxonomy (failure modes and Agent handling).

# 3. Qualification Gate

Three promotion gates—coverage test (all parameter combos and edge cases) → gate check (contract validation—complete I/O schema and error handling) → regression suite (new tool must not break existing tools). Pass all three to reach production.

# 4. Version Management

Tool versions bind to the Agent/Model version that generated them. Provenance records: source_trajectory, generating_model, extraction_params. When underlying EDA tools or AI models upgrade, tools auto-mark stale and trigger re-qualification.

# 5. Rollback

Auto-demote underperforming tools. The factory monitors production metrics (success rate, avg runtime, violation rate). Sustained under-threshold performance over N calls demotes to degraded or rolls back to the last stable version. Demotion events trigger alerts and audit log entries.

# Agent invocation

Tool Factory operations are triggered by admins or senior Agents—pattern extraction and tool generation are low-frequency infrastructure self-evolution, not hot-path calls.

from ieda.factory import ToolFactory

factory = ToolFactory("http://localhost:9140")

# Step 1: Extract pattern from trajectory
pattern = factory.extract(
    trajectory_ref="traj_7f3a",
    min_occurrences=5,
    pattern_type="composite_tool",
)
print(pattern.name)          # "hotspot_swap"
print(pattern.frequency)      # 12
print(pattern.operations)     # ["iPL.local_swap", "iSTA.incremental", "evaluate_hpwl"]

# Step 2: Generate tool from pattern
result = factory.generate(
    pattern_ref=pattern.ref,
    qualification_level="F2",
)

print(result.tool_contract)     # typed contract with schema
print(result.qualification)   # {coverage: "pass", gate: "pass", regression: "pass"}
print(result.promotion)       # "production"

// Extract pattern from trajectory
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "factory.extract",
    "arguments": {
      "trajectory_ref": "traj_7f3a",
      "min_occurrences": 5,
      "pattern_type": "composite_tool"
    }
  }
}

// Generate tool and run qualification
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "factory.generate",
    "arguments": {
      "pattern_ref": "pattern_hotspot_swap_v1",
      "qualification_level": "F2"
    }
  }
}

# Extract pattern from agent trajectory
factory extract -trajectory traj_7f3a \
  -min_occurrences 5 -pattern_type composite_tool

# Generate tool and run qualification
factory generate -pattern pattern_hotspot_swap_v1 \
  -qualify F2

# Promote to production (manual or auto)
factory promote -tool hotspot_swap_v1

# Rollback if degraded
factory rollback -tool hotspot_swap_v1 -to_version v0

# Input/output contract

FactoryRequest

FactoryResult

# Related resources