Agentic Workflow Patterns

The simplest pattern: decompose a task into a fixed sequence of LLM calls, each step's output feeding the next step's input. Good when a task naturally breaks into ordered sub-steps that don't need to branch.

Chain: a fixed sequence of steps, each call's output feeding the next.

String outline = chatClient.prompt().user("Outline a blog post about: " + topic).call().content();
String fullPost = chatClient.prompt()
    .user("Expand this outline into a full blog post:\n" + outline)
    .call().content();

String outline = chatClient.prompt().user("Outline a blog post about: " + topic).call().content();
String fullPost = chatClient.prompt()
    .user("Expand this outline into a full blog post:\n" + outline)
    .call().content();

Run multiple independent LLM calls concurrently instead of sequentially, then combine their results — used when sub-tasks genuinely don't depend on each other's output, purely to reduce total latency.

CompletableFuture<String> grammar = CompletableFuture.supplyAsync(() ->
    chatClient.prompt().user("Check grammar issues in: " + text).call().content());
CompletableFuture<String> tone = CompletableFuture.supplyAsync(() ->
    chatClient.prompt().user("Assess the tone of: " + text).call().content());

CompletableFuture.allOf(grammar, tone).join();
String combined = "Grammar: " + grammar.get() + "\nTone: " + tone.get();

CompletableFuture<String> grammar = CompletableFuture.supplyAsync(() ->
    chatClient.prompt().user("Check grammar issues in: " + text).call().content());
CompletableFuture<String> tone = CompletableFuture.supplyAsync(() ->
    chatClient.prompt().user("Assess the tone of: " + text).call().content());

CompletableFuture.allOf(grammar, tone).join();
String combined = "Grammar: " + grammar.get() + "\nTone: " + tone.get();

One LLM call classifies the input, then routes it to a different, specialized prompt (or even a different model entirely) based on that classification — useful when different input categories genuinely need different handling, rather than one generic prompt trying to handle all of them adequately.

public enum Category { BILLING, TECHNICAL, GENERAL }

Category category = chatClient.prompt()
    .user("Classify this support ticket as BILLING, TECHNICAL, or GENERAL: " + ticket)
    .call().entity(Category.class);

String response = switch (category) {
    case BILLING -> billingChatClient.prompt().user(ticket).call().content();
    case TECHNICAL -> technicalChatClient.prompt().user(ticket).call().content();
    case GENERAL -> generalChatClient.prompt().user(ticket).call().content();
};

public enum Category { BILLING, TECHNICAL, GENERAL }

Category category = chatClient.prompt()
    .user("Classify this support ticket as BILLING, TECHNICAL, or GENERAL: " + ticket)
    .call().entity(Category.class);

String response = switch (category) {
    case BILLING -> billingChatClient.prompt().user(ticket).call().content();
    case TECHNICAL -> technicalChatClient.prompt().user(ticket).call().content();
    case GENERAL -> generalChatClient.prompt().user(ticket).call().content();
};

An orchestrator LLM call decides how to decompose the task into sub-tasks at runtime; independent worker calls handle each sub-task; a final synthesis step combines their results — more flexible than a fixed chain or a fixed set of routes, at the cost of being harder to predict and test.

Orchestrator-workers: an orchestrator call decides the sub-tasks at runtime; workers execute them independently; results are synthesized back together.

One LLM call generates a candidate result; a second call (the evaluator) critiques it against explicit criteria; if it fails, the critique feeds back into another generation attempt — looping until the evaluator is satisfied or a max-attempts limit is hit. This directly previews Module 16's Evaluators, applied here as a generation-quality loop rather than a pure safety check.

String draft = chatClient.prompt().user("Write a product description for: " + product).call().content();

for (int attempt = 0; attempt < 3; attempt++) {
    String critique = chatClient.prompt()
        .user("Critique this product description for clarity and persuasiveness. Reply PASS or list issues:\n" + draft)
        .call().content();
    if (critique.startsWith("PASS")) break;
    draft = chatClient.prompt()
        .user("Revise this description to address: " + critique + "\n\nOriginal:\n" + draft)
        .call().content();
}

String draft = chatClient.prompt().user("Write a product description for: " + product).call().content();

for (int attempt = 0; attempt < 3; attempt++) {
    String critique = chatClient.prompt()
        .user("Critique this product description for clarity and persuasiveness. Reply PASS or list issues:\n" + draft)
        .call().content();
    if (critique.startsWith("PASS")) break;
    draft = chatClient.prompt()
        .user("Revise this description to address: " + critique + "\n\nOriginal:\n" + draft)
        .call().content();
}

Every pattern above has a structure your code defines. An agent inverts this: the model itself decides, at each step, what tool to call next and when it has enough information to stop — your code just runs the loop (call model → if it requested a tool, run it and feed back the result → repeat) until the model produces a final answer instead of another tool request. This is exactly Module 12 §12.3's mechanism, simply allowed to repeat multiple times instead of stopping after one tool call.