control-loop-extraction

Dowwie 的头像作者 Dowwie

提取和分析智能体推理循环、步骤函数和终止条件。用于需要(1)理解智能体框架如何实现推理(ReAct、计划-求解、反思等)、(2)定位核心决策逻辑、(3)分析循环机制和终止条件、(4)记录智能体逐步执行流程、或(5)比较不同框架的推理模式时。

📖 中文导读:提取和分析智能体推理循环、步骤函数和终止条件。用于需要(1)理解智能体框架如何实现推理(ReAct、计划-求解、反思等)、(2)定位核心决策逻辑、(3)分析循环机制和终止条件、(4)记录智能体逐步执行流程、或(5)比较不同框架的推理模式时。 以下正文为该技能的原始 SKILL.md 内容(英文),上方安装命令可直接使用。

name: control-loop-extraction description: Extract and analyze agent reasoning loops, step functions, and termination conditions. Use when needing to (1) understand how an agent framework implements reasoning (ReAct, Plan-and-Solve, Reflection, etc.), (2) locate the core decision-making logic, (3) analyze loop mechanics and termination conditions, (4) document the step-by-step execution flow of an agent, or (5) compare reasoning patterns across frameworks.

Control Loop Extraction

Extracts and documents the core agent reasoning loop from framework source code.

Process

  1. Locate the loop - Find the main agent execution loop
  2. Classify the pattern - Identify ReAct, Plan-and-Solve, Reflection, or Tree-of-Thoughts
  3. Extract the step function - Document the LLM → Parse → Decide flow
  4. Map termination - Catalog all loop exit conditions

Reasoning Pattern Identification

Pattern Signatures

ReAct (Reason + Act)

# Signature: Thought → Action → Observation cycle
while not done:
    thought = llm.generate(prompt)      # Reasoning
    action = parse_action(thought)       # Action selection
    observation = execute(action)        # Environment feedback
    prompt = update_prompt(observation)  # Loop continuation

Plan-and-Solve

# Signature: Upfront planning, then execution
plan = llm.generate("Create a plan for...")
for step in plan.steps:
    result = execute_step(step)
    if needs_replan(result):
        plan = replan(...)

Reflection

# Signature: Act → Self-critique → Adjust
while not done:
    action = llm.generate(prompt)
    result = execute(action)
    critique = llm.generate(f"Evaluate: {result}")
    if critique.needs_adjustment:
        prompt = adjust_approach(critique)

Tree-of-Thoughts

# Signature: Branch → Evaluate → Select
thoughts = [generate_thought() for _ in range(n)]
scores = [evaluate(t) for t in thoughts]
best = select_best(thoughts, scores)

Step Function Analysis

The "step function" is the atomic unit of agent execution. Extract:

  1. Input Assembly - How context is constructed for the LLM
  2. LLM Invocation - The actual model call
  3. Output Parsing - How raw output becomes structured actions
  4. Action Dispatch - Tool execution vs. final response routing

Key Code Patterns

# Common step function structure
def step(self, state):
    # 1. Assemble input
    messages = self._build_messages(state)
    
    # 2. Call LLM
    response = self.llm.invoke(messages)
    
    # 3. Parse output
    parsed = self._parse_response(response)
    
    # 4. Dispatch
    if parsed.is_tool_call:
        return self._execute_tool(parsed.tool, parsed.args)
    else:
        return AgentFinish(parsed.final_answer)

Termination Condition Catalog

Common Termination Patterns

Condition Implementation Risk
Step limit if step_count >= max_steps May cut off valid execution
Token limit if total_tokens >= max_tokens May truncate mid-thought
Explicit finish if action.type == "finish" Relies on LLM cooperation
Timeout if elapsed > timeout Wall-clock unpredictable
Loop detection if state in seen_states Requires state hashing
Error threshold if error_count >= max_errors May exit on recoverable errors

Anti-Pattern: No Termination Guard

# DANGEROUS: No exit condition
while True:
    result = agent.step()
    if result.is_done:  # What if LLM never outputs done?
        break

Fix: Always include a step counter:

for step in range(max_steps):
    result = agent.step()
    if result.is_done:
        break
else:
    logger.warning("Hit max steps limit")

Output Template

## Control Loop Analysis: [Framework Name]

### Reasoning Topology
- **Pattern**: [ReAct | Plan-and-Solve | Reflection | Tree-of-Thoughts | Hybrid]
- **Location**: `path/to/agent.py:L45-L120`

### Step Function
- **Input Assembly**: [Description of context building]
- **LLM Call**: [Method and parameters]
- **Parser**: [How output is structured]
- **Dispatch Logic**: [Tool vs Finish decision]

### Termination Conditions
1. [Condition 1 with code reference]
2. [Condition 2 with code reference]
3. ...

### Loop Detection
- **Method**: [Heuristic | State hash | None]
- **Implementation**: [Code reference or N/A]

Integration Points

  • Prerequisite: codebase-mapping to identify agent files
  • Feeds into: comparative-matrix for pattern comparison
  • Feeds into: architecture-synthesis for new loop design