Przejdź do treści
Biblioteka skilli
AI i agenci · Planowanie

ai-agentic-workflows

/ai-agentic-workflows

Projektuje przepływ sterowania wokół LLM: wybiera wzorzec, ogranicza pętle i wskazuje miejsca, w których człowiek sprawdza wynik.

Repozytorium
agent-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

95/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Projektuje przepływ sterowania wokół LLM: wybiera wzorzec, ogranicza pętle i wskazuje miejsca, w których człowiek sprawdza wynik.

Wyzwalacze z opisu

agentic workflowagent loopReActplan and executeplanner executorreflection loopevaluator-optimizerprompt chaining
Oryginalny opis (EN)

Use this skill when the user says 'agentic workflow', 'agent loop', 'ReAct', 'plan and execute', 'planner executor', 'reflection loop', 'evaluator-optimizer', 'prompt chaining', 'LangGraph workflow'. Designs the control flow around an LLM: which workflow pattern to pick (chain, router, parallel, orchestrator-workers, evaluator-optimizer, autonomous agent), how to bound loops, and where to put human checkpoints. Do NOT use for: multi-agent topology choices (ai/multi-agent-systems), the internals of a single agent loop (ai/ai-agents/core-architectures), or tool schema design (ai/ai-agents/tool-c

Jak działa

  1. Purpose
  2. Agent Protocol
  3. Pattern Decision Tree
  4. Core Loops
  5. Implementation (LangGraph)
  6. Bounding Autonomous Loops
  7. Anti-Patterns
  8. Checklist
  9. References
Sekcje z nagłówków SKILL.md, w oryginale · 181 linii, 1 219 słów
Podgląd SKILL.md
---
name: ai-agentic-workflows
description: >
  Use this skill when the user says 'agentic workflow', 'agent loop', 'ReAct', 'plan and execute', 'planner executor', 'reflection loop', 'evaluator-optimizer', 'prompt chaining', 'LangGraph workflow'. Designs the control flow around an LLM: which workflow pattern to pick (chain, router, parallel, orchestrator-workers, evaluator-optimizer, autonomous agent), how to bound loops, and where to put human checkpoints. Do NOT use for: multi-agent topology choices (ai/multi-agent-systems), the internals of a single agent loop (ai/ai-agents/core-architectures), or tool schema design (ai/ai-agents/tool-calling-principles).
version: "2.0.0"
author: "j4flmao"
license: "MIT"
tags: [ai, agents, agentic-workflows, react, planning, langgraph, orchestration]
---

# Agentic Workflows

## Purpose
Choose and implement the simplest control flow that solves the task reliably. Most production "agents" are workflows: predefined code paths that call an LLM at specific steps. Reserve open-ended autonomous loops for tasks whose number of steps cannot be known in advance, and always bound them with step limits, budgets, and checkpoints.

## Agent Protocol

### Trigger
"agentic workflow", "agent loop", "ReAct", "plan-and-execute", "planner/executor", "reflection", "evaluator-optimizer", "prompt chaining", "routing", "orchestrator-workers", "LangGraph".

### Input Context
- The task, its success criterion, and whether the step sequence is known up front.
- Available tools and which ones mutate state (writes, payments, deploys).
- Latency and cost budget per run; acceptable failure rate.
- Framework constraints (plain SDK, LangGraph, other).

### Output Artifact
A workflow design: pattern choice with rationale, state schema, node/step list, loop bounds, HITL points, and eval plan. Code only if requested.

### Response Format
```
Pattern: {chain|router|parallel|orchestrator-workers|evaluator-optimizer|autonomous}
Why not simpler: {one line}
State: {typed fields}
Steps: {step -> step (condition)}
Bounds: max_steps={n}, max_cost={usd}, timeout={s}
Human checkpoints: {before which actions}
Eval: {dataset + metric}
```

### Completion Criteria
- [ ] Simplest viable pattern chosen and justified.
- [ ] Every loop has a hard iteration cap and a budget.
- [ ] State-mutating tools gated by approval or dry-run.
- [ ] Typed state schema, not raw message history only.
- [ ] Offline eval set defined before tuning prompts.

## Pattern Decision Tree

```
Is the sequence of steps known in advance?
├── Yes → Is it a single fixed sequence?
│   ├── Yes → Prompt chain (step N output feeds step N+1, with code checks between)
│   └── No, input type decides the path → Router (classify, then dedicated prompt/tool)
├── Partly: subtasks are independent → Parallelization (sectioning or voting), then aggregate
├── Subtasks only known after reading the input → Orchestrator-workers
├── Quality improves with critique and clear criteria exist → Evaluator-optimizer loop
└── Open-ended, many steps, environment feedback needed → Autonomous agent (ReAct-style loop)
```

| Pattern | Latency | Cost | Predictability | Typical use |
|---|---|---|---|---|
| Prompt chain | Sum of steps | Low | High | Draft → translate → format |
| Router | 1 extra call | Low | High | Support ticket triage |
| Parallel (voting) | Max of branches | N× | High | Moderation with majority vote |
| Orchestrator-workers | Variable | Medium | Medium | Multi-file code change |
| Evaluator-optimizer | k × (gen + eval) | Medium | Medium | Translation, constrained writing |
| Autonomous agent | Unbounded unless capped | High | Low | Coding agents, research |

## Core Loops

### ReAct
Interleave reasoning and tool use: the model decides an action, the harness executes it, the observation is appended, repeat until the model returns a final answer. With native tool calling, "Thought/Action/Observation" text parsing is unnecessary: the API returns structured tool-call blocks.

### Plan-and-Execute
A planner produces an explicit step list; an executor runs each step (often a small ReAct loop); a re-planner revises the remaining plan after each step. Better on long tasks because the plan is persisted state, not something the model must remember. Re-planning is mandatory: a static plan breaks on the first surprise.

### Evaluator-Optimizer (Reflection)
Generator produces output; evaluator scores it against explicit criteria and returns actionable feedback; loop until pass or cap. Reflection without an external signal (tests, schema validation, retrieval check) often just rephrases the same mistake, so prefer evaluators grounded in execution results.

## Implementation (LangGraph)

```python
from __future__ import annotations

from typing import Literal, TypedDict

from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import END, START, StateGraph


class State(TypedDict):
    task: str
    draft: str
    feedback: str
    passed: bool
    attempts: int


MAX_ATTEMPTS = 3


def generate(state: State) -> dict:
    draft = call_llm(f"Task: {state['task']}\nPrevious feedback: {state['feedback']}")
    return {"draft": draft, "attempts": state["attempts"] + 1}


def evaluate(state: State) -> dict:
    errors = run_checks(state["draft"])  # deterministic checks first: tests, schema, linters
    return {"passed": not errors, "feedback": "\n".join(errors)}


def route(state: State) -> Literal["generate", "publish", "give_up"]:
    if state["passed"]:
        return "publish"
    return "give_up" if state["attempts"] >= MAX_ATTEMPTS else "generate"


builder = StateGraph(State)
builder.add_node("generate", generate)
builder.add_node("evaluate", evaluate)
builder.add_node("publish", publish)    # state-mutating: guarded by interrupt below
builder.add_node("give_up", escalate_to_human)
builder.add_edge(START, "generate")
builder.add_edge("generate", "evaluate")
builder.add_conditional_edges("evaluate", route)
builder.add_edge("publish", END)
builder.add_edge("give_up", END)

graph = builder.compile(checkpointer=MemorySaver(), interrupt_before=["publish"])
config = {"configurable": {"thread_id": "job-42"}}
graph.invoke({"task": "...", "draft": "", "feedback": "", "passed": False, "attempts": 0}, config)
# Human reviews graph.get_state(config); resume with graph.invoke(None, config)
```

`call_llm`, `run_checks`, `publish`, and `escalate_to_human` are your application functions. Use a durable checkpointer (Postgres/SQLite saver) in production so interrupted runs survive restarts.

## Bounding Autonomous Loops
- **Hard caps**: max steps, max tokens, max wall-clock, max USD per run. Abort with a clear error, never silently truncate.
- **Loop detection**: hash (tool, args) pairs; if the same call repeats with the same result, inject "this failed before, change strategy" or stop.
- **Progress signal**: require each iteration to change state (new file, new fact, test count); stop on N iterations without progress.
- **Context management**: summarize or drop stale observations; keep the plan, constraints, and latest results verbatim.
- **Idempotent tools**: retries after timeouts must not double-apply side effects.

## Anti-Patterns
| Anti-pattern | Symptom | Fix |
|---|---|---|
| Agent where a chain suffices | Slow, flaky, expensive | Hard-code the known steps |
| Unbounded loop | Runaway cost, repeated identical calls | Caps + loop detection |
| Self-critique with no ground truth | "Improved" output with the same bug | Evaluate with tests/validators |
| Plan never revised | Executor follows obsolete steps | Re-plan after every step |
| All state in chat history | Lost constraints after summarization | Typed state fields |
| Destructive tool without checkpoint | Irreversible mistakes | `interrupt_before` / approval step |

## Checklist
- [ ] Pattern chosen from the decision tree; simpler options ruled out explicitly.
- [ ] Typed state with the fields each step reads and writes.
- [ ] Caps: steps, tokens, time, cost.
- [ ] Deterministic validators run before any LLM judge.
- [ ] HITL before irreversible actions; durable checkpointer.
- [ ] Traces captured per step (inputs, outputs, tool calls, cost).
- [ ] Offline eval set with pass/fail metric, run on every prompt change.

## References
- Yao et al., "ReAct: Synergizing Reasoning and Acting in Language Models" (ICLR 2023).
- Wang et al., "Plan-and-Solve Prompting" (ACL 2023).
- Anthropic, "Building effective agents" (Dec 2024) — workflow vs agent taxonomy.
- LangGraph documentation: StateGraph, checkpointers, interrupts.

### Shared References
Additional reference material for this skill, stored outside its own `references/` folder.

- `../../harness-engineering/agent-legibility/references/agent-optimized-readmes.md` — Agent-Optimized READMEs
- `../../harness-engineering/agent-legibility/references/agents-md-design.md` — AGENTS.md Design Reference
- `../../harness-engineering/agent-legibility/references/codebase-navigation-hints.md` — Codebase Navigation Hints for Agents
- `../../harness-engineering/agent-legibility/references/convention-constraint-files.md` — Convention and Constraint Files Reference
- `../../harness-engineering/agent-legibility/references/progressive-context-disclosure.md` — Progressive Context Disclosure for Agents
- `../../harness-engineering/agent-legibility/references/repo-native-instructions.md` — Repository-Native Instructions Reference
- `../../harness-engineering/agent-legibility/references/structured-documentation.md` — Structured Documentation Reference
- `../../harness-engineering/agent-legibility/references/workspace-configuration.md` — Workspace Configuration for Coding Agents
- `../../harness-engineering/feedback-loops/references/automated-validation-hooks.md` — Automated Validation Hooks
- `../../harness-engineering/feedback-loops/references/continuous-improvement-loops.md` — Continuous Improvement Loops for Agents
- `../../harness-engineering/feedback-loops/references/correction-trigger-mechanisms.md` — Correction Trigger Mechanisms
- `../../harness-engineering/feedback-loops/references/hitl-checkpoint-design.md` — Human-in-the-Loop (HITL) Checkpoint Design
- `../../harness-engineering/feedback-loops/references/implement-verify-fix-cycles.md` — Implement-Verify-Fix (IVF) Cycles
- `../../harness-engineering/feedback-loops/references/output-verification-layers.md` — Output Verification Layers
- `../../harness-engineering/feedback-loops/references/quality-gate-frameworks.md` — Quality Gate Frameworks for Agent Work
- `../../harness-engineering/feedback-loops/references/reflection-patterns.md` — Reflection Patterns
- `../../harness-engineering/feedforward-controls/references/anticipatory-error-prevention.md` — Anticipatory Error Prevention (Feedforward Controls)

Wersje

W bazie nie ma innych skilli o nazwie ai-agentic-workflows.

Migawka bazy z 13.11.2026 · wersja paczki 3f8c16189842 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100cc-agentic-patterns
    Dobiera i wdraża wzorzec projektowy agentów, taki jak refleksja, łańcuch promptów, routing, równoległość, orchestrator-workers, evaluator-optimizer, ReAct i blackboard, w 5-warstwowym stosie Claude Code.
  • 100agent-workflow-patterns
    Buduje systemy LLM ze składanych wzorców przepływu (łańcuchy promptów, routing, paralelizacja, orchestrator-workers, evaluator-optimizer) i pomaga wybrać między przepływem a autonomicznym agentem.
  • 90agentic-architecture
    Projektuje architekturę systemów agentów LLM: topologie orkiestracji, strategię pamięci i kontekstu, warstwę narzędzi oraz kontrolę człowieka, na poziomie architekta.
  • 93ai-agent-core-loop
    Wyjaśnia i wdraża pętlę sterowania pojedynczego agenta: obserwacje, wybór działania, zakończenie, ponowne planowanie i refleksję.
  • 100agentic-architecture
    Pomaga zdecydować, czy system oparty na LLM potrzebuje agenta czy deterministycznego workflow, jaki wzorzec orkiestracji wybrać, ilu agentów użyć oraz gdzie dać bramki zatwierdzeń i jak kończyć pętle w budżecie.
  • 100design-ai-agent-skills
    Pogłębia architekturę agentów AI i systemów wieloagentowych, pisze dokumenty projektu i ocenia istniejące projekty według sprawdzonych wzorców.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.