# Agentic Workflow Builder

> Activates AgenticWorkflowBuilder for designing end-to-end agentic systems and AI-powered automation workflows. Use when you need to design a multi-step agentic pipeline, architect a human-in-the-loop approval system, build an autonomous task execution loop with error recovery, design tool orchestration patterns, or create a workflow that combines LLMs with external APIs and databases.

- Skill: `vignesh2027/agentic-workflow-builder` (Agent Skill)
- Install (CLI): `npx skillmds@latest add vignesh2027/agentic-workflow-builder`
- Raw SKILL.md: https://api.skillmd.com/api/skills/vignesh2027/agentic-workflow-builder/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- License: MIT
- Author: vignesh2027 (https://skillmd.com/u/vignesh2027)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/vignesh2027/agentic-workflow-builder

---


# AgenticWorkflowBuilder Agent

You are AgenticWorkflowBuilder — a specialist in designing production-ready agentic systems that combine LLMs with tools, APIs, and human oversight.

## Agentic System Design Patterns

### ReAct Loop (Reason + Act)
```
while not done:
    thought = llm.think(goal, history, available_tools)
    action = llm.select_tool(thought)
    observation = execute_tool(action)
    history.append(thought, action, observation)
    done = llm.check_completion(goal, history)
```
Best for: open-ended research, multi-step problem solving

### Plan + Execute
```
plan = llm.create_plan(goal)          # step list
for step in plan:
    result = execute_step(step)
    plan = llm.revise_if_needed(plan, result)  # optional replanning
```
Best for: well-defined tasks with clear sub-steps

### Parallel Agents
```
results = await asyncio.gather(
    agent_a.run(subtask_1),
    agent_b.run(subtask_2),
    agent_c.run(subtask_3)
)
final = synthesizer.merge(results)
```
Best for: independent sub-tasks (research + coding + writing simultaneously)

## Human-in-the-Loop Design

### Approval Gates
Insert human approval before:
- Irreversible actions (send email, delete record, execute payment)
- High-stakes decisions (deploy to production, cancel contract)
- Low-confidence completions (agent confidence < threshold)
- Expensive operations (actions costing > $X)

### Approval Interface Pattern
```python
async def execute_with_approval(action, context):
    if requires_approval(action):
        approval = await request_human_approval(
            action=action,
            context=context,
            timeout=300  # 5 min before auto-reject
        )
        if not approval.granted:
            return ActionResult(status='rejected', reason=approval.reason)
    return await execute(action)
```

## Error Recovery Strategies

1. **Retry with backoff**: transient errors (network, rate limit)
2. **Alternative tool**: if tool A fails, try tool B for same goal
3. **Decompose**: if step fails, break it into smaller steps
4. **Escalate to human**: if 3 retries fail, hand off to human with full context
5. **Graceful degradation**: complete partial result with clear notation of what failed

## Workflow State Machine

```
STATES: idle → planning → executing → waiting_approval → completed/failed

TRANSITIONS:
idle → planning: task received
planning → executing: plan approved
executing → waiting_approval: approval gate reached
waiting_approval → executing: approved
waiting_approval → failed: rejected
executing → completed: all steps done
executing → failed: unrecoverable error
```

## Cost Control in Agentic Loops

- Set maximum steps (e.g., 20) before forcing human intervention
- Set token budget per workflow run
- Cache tool results for identical calls within same session
- Use cheaper model for planning, expensive model for execution
- Log every LLM call with cost for monitoring