Agent Planner · Planning engine

# decompose goal into typed plan $ planner.plan("Optimize critical-path timing") [step 1] STA identify critical paths [step 2] Resize cells on path top-3 [step 3] Verify timing delta → critic monitors, recovery on failure

Core capabilities

1. Plan Generation

Decompose goals (natural language or DSL) into sub-task sequences: goal → sub-plan → tool selection → dependency ordering. Each sub-task has explicit I/O contracts and expected thresholds. Supports sequential, parallel, conditional dependencies.

2. Critic

Monitor execution after each sub-task for goal drift. Critic does not modify the plan—it emits on-track / deviation-detected / goal-violated reports for Planner decisions.

3. Recovery

Auto-generate alternatives on sub-task failure. Recovery: rollback to checkpoint, swap toolchain, adjust parameters, relax goals (e.g., +5% area for timing convergence). All recovery paths pass Gate evaluation.

4. Stop Criteria

Hard vs soft gates:

Hard gates: constraint violations (e.g., area overrun), budget exhaustion (wall-clock or tool calls), unrecoverable errors.
Soft gates: diminishing returns (N rounds improvement < threshold), goal met but further tuning yields little gain.

Agent calling patterns

from ieda.agent import Planner, Goal, StopCriteria

planner = Planner()

goal = Goal(
    target="Optimize critical-path timing，no more than 5% area increase",
    constraints={"area_budget_pct": 5.0},
    quality={"timing_slack_ps": -50}
)

plan = planner.plan(goal)

# plan.result: TypedPlan {
#   steps: [Step("sta-analyze", tool="iSTA"),
#           Step("resize-critical", tool="iPL", deps=["sta-analyze"]),
#           Step("verify", tool="iSTA", deps=["resize-critical"])],
#   stop: HardStop("area_budget_pct <= 5.0"),
#   critic: OnStepComplete("verify") -> CompareDelta("timing_slack_ps")
# }

result = planner.execute(plan, db=current_idb)
# critic runs after each step, recovery triggers on failure

// MCP: Agent invokes Planner via standard interface
{
  "method": "tools/call",
  "params": {
    "name": "planner.plan",
    "arguments": {
      "goal": "Optimize critical-path timing，no more than 5% area increase",
      "tool_capabilities": ["iSTA", "iPL", "iCTS"],
      "design_snapshot": "checkpoint:v3",
      "stop": {
        "hard": ["area_budget_pct <= 5.0", "runtime_sec <= 3600"],
        "soft": ["delta_timing_pct < 0.5"]
      }
    }
  }
}

# Tcl: invoke Planner via iEDA flow script
ieda::planner plan \
  -goal "Optimize critical-path timing" \
  -constraint {area_budget_pct 5.0} \
  -quality {timing_slack_ps -50} \
  -tools {iSTA iPL iCTS}

ieda::planner execute -db current_idb -monitor on

# Check plan status
ieda::planner status  ;# running | completed | failed | recovered

Input / output contract

Direction	Field	Type	Description
Input	`goal`	str \| Goal	Natural-language or structured goal description
Input	`constraints`	dict	Hard constraints: area, power, time budget
Input	`tool_capabilities`	list[str]	Available tools (for tool selection)
Input	`design_snapshot`	str	Design checkpoint identifier
Output	`plan`	TypedPlan	Full plan with steps, deps, stop, critic
Output	`execution_trace`	Trace	Per-step I/O/runtime/result
Output	`recovery_log`	list[Recovery]	All recovery events and alternatives

Agent RuntimeAgent execution engine & state management Intent ScenarioImmutable design intent & constraint management Verification HubVerification orchestration & certificates

Agent Planner · Goal decomposition & execution monitor