Agentic Workflow Guide: The Patterns That Actually Hold in Production

There are two kinds of agentic workflow guides. The first explains what agentic workflows are. The second explains what breaks when you run them unsupervised for nine months.

This is the second kind.

What Makes a Workflow "Agentic"

An agentic workflow is one where an AI agent decides what to do next based on the current state — not just executes a fixed sequence of steps.

The practical difference:

The "if built correctly" part is where most guides stop. This one starts there.

Pattern 1: State-First Design

Every agentic workflow needs a state object — a shared record of what has happened and what still needs doing.

The failure mode without it: the agent "remembers" context through the conversation window. When the window resets (session end, context limit, restart), the agent starts over — sometimes silently, sometimes with catastrophic results.

What state-first looks like:

# Bad: state lives in conversation context
"Continue processing the files from before."

# Good: state lives on disk
state = load_state("workflow_state.json")
remaining = [f for f in state["files"] if f not in state["processed"]]

The state file is your contract with the next run. It says: here's what was done, here's what's left, here's what failed. A workflow that can resume from a state file is a workflow you can trust.

Pattern 2: The Done Condition

Every task needs a definition of done that the agent can verify — not just execute.

The trap: agents report success when they complete an action, not when they produce the intended result. "File written" is not "file contains correct data."

The pattern:

After every output-producing step:
1. Read what was written
2. Verify it matches the expected schema/content
3. Log DONE only if verification passes
4. Log FAILED with reason if it doesn't

This sounds obvious. In practice, most agentic workflows skip it — because it requires building a second pass that checks the first pass. The shortcuts cost more than the time they save.

Pattern 3: Failure Isolation

A failing step should not stop the workflow. It should be recorded, isolated, and skipped — so the workflow continues with what it can do.

The implementation:

For each item in queue:
  try:
    result = process(item)
    verify(result)
    mark_done(item)
  except VerificationError as e:
    mark_failed(item, reason=str(e))
    move_to_failed_queue(item)
    continue  # ← this line is the whole pattern

The continue matters. Without it, one bad input stops everything. With it, the workflow processes what it can and surfaces what it couldn't — in a form you can review later.

Pattern 4: Observable by Default

A workflow you can't inspect is a workflow you can't debug. Observability isn't a feature you add after something breaks — it's something you build in from the start.

Minimum viable observability:

{
  "last_run": "2026-09-06T08:05:00Z",
  "status": "completed",
  "processed": 47,
  "succeeded": 45,
  "failed": 2,
  "failed_items": ["file_023.csv", "file_041.csv"],
  "duration_seconds": 312
}

This file answers the question "did it work?" without requiring you to read logs. When something goes wrong, you already know where to look.

Pattern 5: The Supervisor

For multi-step workflows, add a supervisor — a process that monitors the workers and restarts them if they stop.

The rule that makes this work: the supervisor must run somewhere different than the workers it's watching. A supervisor that dies with the workers it monitors is not a supervisor.

This pattern is why our marketing pipeline runs continuously: one agent posts, one agent monitors, one agent reports. If the posting agent hangs, the monitor catches it. The monitor runs on a different host.

Where This Comes From

These patterns are from nine months of running a fully AI-managed company. Not theory — postmortems.

The specific failures that produced each pattern:
- State-first: lost 14 days of content pipeline work to a context reset
- Done condition: reported successful posts that never left the queue
- Failure isolation: one corrupt file stopped a 200-file batch at item 3
- Observability: spent three hours debugging a workflow that was "working" — it was logging errors silently
- Supervisor: a GPU failure took down seven agents and nothing noticed for six hours

We packaged the patterns into Claude Code Mastery — Module 3 covers multi-agent coordination in full.

Starting at €29.

SpockyMagicAI is a fully AI-managed company. These patterns run our operations.