Seven shapes of agent — and when to reach for each.

Pattern 01 · Prompt chaining

When the steps are known up front, just chain them.

The most common production "AI feature" is a fixed sequence of two or three model calls — extract → classify → summarize, or research → outline → write. No loop, no agent. Just a function that calls the model the right number of times.

Use it when

• You can describe the algorithm in three bullet points before you've seen any input.
• Each step has a measurable, gated checkpoint (validate the JSON, check the classification confidence).
• Latency budget is tight — chains are predictable; agents are not.

// summarize → translate → format. Plain Go, no framework.
func Translate(ctx context.Context, doc string) (string, error) {
    summary, err := llm.Once(ctx,
        "Summarize the document below in 80 words.", doc)
    if err != nil { return "", err }

    german, err := llm.Once(ctx,
        "Translate to German, preserving tone.", summary)
    if err != nil { return "", err }

    final, err := llm.Once(ctx,
        "Format as Markdown with headings.", german)
    return final, err
}

Pattern 03 · Parallelization

Two flavors: sectioning (split work) and voting (consensus).

When the work is independent, fan out. Sectioning splits a long input into chunks and processes each in parallel. Voting runs the same prompt N times and combines outputs (majority, ranked, ensembled). Go's errgroup makes both trivial.

When to vote

• Safety-critical classification (is this content allowed) — N=3 voters cuts false negatives.
• Code review with diverse personas — same code, three different reviewer prompts, merge findings.
• Eval consensus — when you don't have a ground-truth answer, multiple model judges approximate one.

import "golang.org/x/sync/errgroup"

func SummarizeShards(ctx context.Context, shards []string) ([]string, error) {
    out     := make([]string, len(shards))
    g, gctx := errgroup.WithContext(ctx)
    g.SetLimit(8) // concurrency cap; respect provider rate limits.

    for i, s := range shards {
        i, s := i, s
        g.Go(func() error {
            summary, err := llm.Once(gctx,
                "Summarize this in 60 words.", s)
            out[i] = summary
            return err
        })
    }
    return out, g.Wait()
}

Pattern 05 · Reflection

A second pass with a critic prompt is the cheapest quality lift in the catalog.

Generate a draft, run the same model with a critic system prompt, hand the critique back, generate a revision. One extra round-trip — and the output quality jumps in a way that's frequently visible to humans in blind comparison.

When to use it

• Long-form generation (reports, articles, code reviews) where one-shot output reads first-draft.
• Code generation — a critic pass catches obvious bugs the generator missed.
• Anything where "did I really cover the brief" is a useful question to ask.

When to skip it

• Latency-sensitive paths. Reflection roughly doubles wall time.
• Trivially-checkable outputs (classification, extraction). Validate with code, not a critic.

func Reflect(ctx context.Context, brief string) (string, error) {
    draft, err := llm.System(ctx,
        "You are a senior writer. Produce a thorough first draft.",
        brief)
    if err != nil { return "", err }

    critique, err := llm.System(ctx,
        "You are a ruthless editor. List concrete problems with the draft.",
        "BRIEF:\n"+brief+"\n\nDRAFT:\n"+draft)
    if err != nil { return "", err }

    return llm.System(ctx,
        "You are the writer. Revise to address every critique below.",
        fmt.Sprintf("DRAFT:\n%s\n\nCRITIQUE:\n%s", draft, critique))
}