AI Agentic Workflows

In the rapidly evolving landscape of artificial intelligence, agentic workflows empower developers to create sophisticated, autonomous systems that leverage large language models (LLMs) with enhanced capabilities like tool calling and task orchestration. These workflows provide structured approaches to break down complex tasks, route queries efficiently, parallelize operations, coordinate multi-step processes, and iteratively optimize outputs. This article explores five foundational agentic workflow patterns, complete with practical examples, to help developers design robust AI agents for real-world applications.

---

1. Prompt Chaining

When to Use:

• Structured multi-step tasks
• Where outputs of one step feed the next

Example: Generate a commit message and validate it

import { generateText } from "ai";

async function generateCommitMessage(diff) {
  const raw = await generateText({
    model: "gpt-4",
    prompt: `Write a conventional commit message for this diff:\n${diff}`,
  });

  const valid = /^(feat|fix|docs|chore)/.test(raw);

  if (!valid) {
    return await generateText({
      model: "gpt-4",
      prompt: `Fix this commit message to follow conventional commit format:\n${raw}`,
    });
  }

  return raw;
}

---

2. Routing

When to Use:

• Tasks vary by type or domain
• Specialized models or paths needed

Example: Classify and delegate user query

import { generateObject, generateText } from "ai";
import { z } from "zod";

const schema = z.object({
  type: z.enum(["code", "creative", "search"]),
  reason: z.string(),
});

const modelMap = {
  code: "claude",
  creative: "gpt-4",
  search: "gemini",
};

async function routeQuery(query) {
  const { type } = await generateObject({
    model: "gpt-4",
    schema,
    prompt: `Classify the query into code, creative, or search:\n${query}`,
  });

  return await generateText({ model: modelMap[type], prompt: query });
}

---

3. Parallelization

When to Use:

• Multitasking subtasks simultaneously
• Independent analysis by multiple agents

Example: Review code for security, performance, and maintainability

import { generateObject, generateText } from "ai";

async function reviewCode(code) {
  const tasks = [
    {
      label: "security",
      prompt: `List security issues in this code:\n${code}`,
    },
    { label: "performance", prompt: `Find performance bottlenecks:\n${code}` },
    {
      label: "maintainability",
      prompt: `Comment on maintainability:\n${code}`,
    },
  ];

  const reviews = await Promise.all(
    tasks.map((task) =>
      generateText({ model: "gpt-4", prompt: task.prompt }).then((result) => ({
        type: task.label,
        result,
      }))
    )
  );

  const summary = await generateText({
    model: "gpt-4",
    prompt: `Summarize the following review results:
${JSON.stringify(reviews)}`,
  });

  return summary;
}

---

4. Orchestrator

When to Use:

• Controlled flow with dependency between steps
• Multiple types of tasks need coordination

Example: Implementing a feature with task-specific calls

async function implementFeature(goal) {
  const plan = await generateObject({
    model: "openai/gpt-3.5",
    prompt: `Break down this feature into file tasks with change type:
${goal}`,
  });

  const fileChanges = await Promise.all(
    plan.files.map((file) => {
      const actionPrompt =
        file.changeType === "create"
          ? `Create a new file ${file.path} with purpose: ${file.purpose}`
          : file.changeType === "modify"
          ? `Improve existing file ${file.path}`
          : `Remove unused code in ${file.path}`;

      return generateText({ model: "gpt-4", prompt: actionPrompt });
    })
  );

  return fileChanges;
}

---

5. Evaluator + Optimizer

When to Use:

• Iterative quality improvement
• Evaluation-driven refinement

Example: Improve code comments until quality is acceptable

async function improveComment(code) {
  let comment = await generateText({
    model: "gpt-4",
    prompt: `Write a concise helpful comment for:
${code}`,
  });

  for (let attempt = 0; attempt < 3; attempt++) {
    const evalResult = await generateObject({
      model: "gpt-4",
      schema: z.object({ clarity: z.number(), issues: z.string() }),
      prompt: `Evaluate this comment: ${comment}`,
    });

    if (evalResult.clarity >= 8) break;

    comment = await generateText({
      model: "gpt-4",
      prompt: `Improve this comment based on issues:
${evalResult.issues}`,
    });
  }

  return comment;
}

---

Summary

Together, these patterns form the building blocks for robust, smart, autonomous agents. Agents are basically llms with added functionalities (tools calling) ˚ i wanna paste it to my medium articke