Agent Workflow Builder

The Agent Workflow Builder skill guides you through designing and implementing multi-agent AI systems that can plan, reason, use tools, and collaborate to accomplish complex tasks. Modern AI applications increasingly rely on agentic architectures where LLMs act as reasoning engines that orchestrate actions rather than just generate text.

This skill covers agent design patterns, tool integration, state management, error handling, and human-in-the-loop workflows. It helps you build robust agent systems that can handle real-world complexity while maintaining safety and controllability.

Whether you are building autonomous assistants, workflow automation, or complex reasoning systems, this skill ensures your agent architecture is well-designed and production-ready.

Core Workflows

Workflow 1: Design Agent Architecture

1. Define the agent's scope:
   • What tasks should it handle autonomously?
   • What requires human approval?
   • What is explicitly out of scope?
2. Choose architecture pattern:

   Pattern	Description	Use When
   Single Agent	One LLM with tools	Simple tasks, clear scope
   Router Agent	Classifies and delegates	Multiple distinct domains
   Sequential Chain	Agents in order	Pipeline processing
   Hierarchical	Manager + worker agents	Complex, decomposable tasks
   Collaborative	Peer agents discussing	Requires diverse expertise

3. Design tool set:
   • What capabilities does the agent need?
   • How are tools defined and documented?
   • What are the safety boundaries?
4. Plan state management:
   • Conversation history
   • Task state and progress
   • External system state
5. Document architecture decisions

Workflow 2: Implement Agent Loop

1. Build core agent loop:

   class Agent:
       def __init__(self, llm, tools, system_prompt):
           self.llm = llm
           self.tools = {t.name: t for t in tools}
           self.system_prompt = system_prompt
   
       async def run(self, user_input, max_steps=10):
           messages = [
               {"role": "system", "content": self.system_prompt},
               {"role": "user", "content": user_input}
           ]
   
           for step in range(max_steps):
               response = await self.llm.chat(messages, tools=self.tools)
   
               if response.tool_calls:
                   # Execute tools
                   for call in response.tool_calls:
                       result = await self.execute_tool(call)
                       messages.append({"role": "tool", "content": result})
               else:
                   # Final response
                   return response.content
   
           raise MaxStepsExceeded()
   
       async def execute_tool(self, call):
           tool = self.tools[call.name]
           return await tool.execute(call.arguments)
   

2. Implement tools with clear interfaces
3. Add error handling and retries
4. Include logging and observability
5. Test with diverse scenarios

Workflow 3: Build Multi-Agent System

1. Define agent roles:

   agents = {
       "planner": Agent(
           llm=gpt4,
           tools=[search, create_task],
           system_prompt="You decompose complex tasks into steps..."
       ),
       "researcher": Agent(
           llm=claude,
           tools=[web_search, read_document],
           system_prompt="You gather and synthesize information..."
       ),
       "executor": Agent(
           llm=gpt4,
           tools=[code_interpreter, file_system],
           system_prompt="You execute tasks and produce outputs..."
       ),
       "reviewer": Agent(
           llm=claude,
           tools=[validate, provide_feedback],
           system_prompt="You review work for quality and correctness..."
       )
   }
   

2. Implement orchestration:
   • How do agents communicate?
   • Who decides what runs when?
   • How is work passed between agents?
3. Manage shared state:
   • Task board or work queue
   • Shared memory or context
   • Artifact storage
4. Handle failures gracefully
5. Add human checkpoints where needed

Quick Reference

Best Practices

• Start Simple: Single agent with tools before multi-agent

  • Prove value with minimal complexity
  • Add agents only when necessary
  • Each agent should have clear, distinct responsibility

• Design Tools Carefully: Tools are the agent's hands

  • Clear, descriptive names and documentation
  • Well-defined input/output schemas
  • Proper error handling an

...