<div id="readability-page-1" class="page"><div><img src="https://devstarsj.github.io/assets/https://images.unsplash.com/photo-1677442135703-1787eea5ce01?w=1600&amp;auto=format&amp;fit=crop&amp;q=80"><h2 id="introduction">Introduction</h2>The shift from chatbots to agentic AI is the defining change in applied ML in 2026. Instead of a single round-trip prompt → response, agentic systems plan multi-step tasks, call tools, spawn sub-agents, and self-correct — all autonomously. The promise is enormous; the failure modes are equally creative.This guide distills hard-won patterns for teams moving agentic workflows from demos into production.<img src="https://images.unsplash.com/photo-1620712943543-bcc4688e7485?w=1200&amp;auto=format&amp;fit=crop&amp;q=80" alt="Agentic AI orchestration diagram">Photo by <a href="https://unsplash.com/@possessedphotography">Possessed Photography</a> on Unsplash<hr><h2 id="what-makes-a-workflow-agentic">What Makes a Workflow “Agentic”?</h2>A workflow is agentic when the model drives the control flow. Three markers:<table><thead><tr><th>Property</th><th>Classic LLM Call</th><th>Agentic Workflow</th></tr></thead><tbody><tr><td>Control flow</td><td>Deterministic, developer-defined</td><td>Model-driven</td></tr><tr><td>Tool use</td><td>Optional, single</td><td>Required, multi-step</td></tr><tr><td>Scope</td><td>Single turn</td><td>Multi-turn or indefinite</td></tr></tbody></table>The practical implication: bugs become emergent rather than deterministic. Your model can choose to call a tool you didn’t expect, in an order you didn’t anticipate, with arguments just outside valid range.<hr><h2 id="architecture-patterns">Architecture Patterns</h2><h3 id="1-single-agent-with-tool-loop">1. Single-Agent with Tool Loop</h3>The simplest production pattern. One model + a tool registry + a loop:<div><pre><code>async def run_agent(task: str, max_steps: int = 20) -&gt; str:
 messages = [{"role": "user", "content": task}]
 
 for step in range(max_steps):
 response = await llm.complete(messages, tools=TOOL_REGISTRY)
 
 if response.stop_reason == "end_turn":
 return response.content
 
 # Execute tool calls
 tool_results = await execute_tools(response.tool_calls)
 messages += [response.message, *tool_results]
 
 raise MaxStepsExceeded(f"Agent exceeded {max_steps} steps")
</code></pre></div>When to use: Tasks where a single model can hold full context — code generation, research summaries, data transformation.Pitfalls:<ul><li>No <code>max_steps</code> guard → runaway costs</li><li>Tool errors must feed back as messages, not exceptions</li><li>Context window exhaustion on long tasks</li></ul><hr><h3 id="2-orchestrator--sub-agents">2. Orchestrator + Sub-Agents</h3>For complex tasks, decompose into an orchestrator that plans and dispatches specialized sub-agents:<div><pre><code>Orchestrator
├── ResearchAgent (web search, summarization)
├── CodeAgent (write, test, debug code)
├── ReviewAgent (verify outputs, flag issues)
└── WriterAgent (final synthesis)
</code></pre></div>The orchestrator never does work directly — it only delegates. Sub-agents are stateless and disposable.<div><pre><code>class OrchestratorAgent:
 async def run(self, task: str) -&gt; str:
 plan = await self.plan(task)
 results = {}
 
 for step in plan.steps:
 agent = self.agents[step.agent_type]
 results[step.id] = await agent.run(
 step.task,
 context={dep: results[dep] for dep in step.dependencies}
 )
 
 return await self.synthesize(results)
</code></pre></div>When to use: Long-horizon tasks, tasks requiring diverse expertise, workflows where sub-tasks can run in parallel.<hr><h3 id="3-graph-based-workflows-langgraph--openai-swarm-patterns">3. Graph-Based Workflows (LangGraph / OpenAI Swarm patterns)</h3>For workflows with conditional branches and cycles, model them as a directed graph:<ul><li>Nodes = agent steps</li><li>Edges = state transitions (including conditional)</li><li>State = shared mutable context</li></ul>This is now the dominant pattern in 2026 frameworks. It provides reproducibility (you can replay any execution) and observability (trace the exact path through the graph).<hr><h2 id="production-concerns">Production Concerns</h2><h3 id="observability">Observability</h3>Agentic traces are deep and branchy. Use structured spans:<div><pre><code>@tracer.start_as_current_span("agent.step")
async def agent_step(messages, tools):
 span = trace.get_current_span()
 span.set_attribute("llm.model", MODEL_ID)
 span.set_attribute("messages.count", len(messages))
 span.set_attribute("tools.available", [t.name for t in tools])
 # ...
</code></pre></div>OpenTelemetry + a backend like Langfuse or Honeycomb gives you per-run cost, latency breakdown by step, and error attribution.<h3 id="cost-control">Cost Control</h3>Agentic systems can burn tokens fast. Establish budgets per run:<div><pre><code>class BudgetedAgent:
 def __init__(self, max_tokens: int = 100_000):
 self.token_budget = max_tokens
 self.tokens_used = 0
 
 def check_budget(self, tokens: int):
 self.tokens_used += tokens
 if self.tokens_used &gt; self.token_budget:
 raise BudgetExceeded(
 f"Used {self.tokens_used} / {self.token_budget} tokens"
 )
</code></pre></div><h3 id="human-in-the-loop">Human-in-the-Loop</h3>Not every decision should be autonomous. Identify approval gates — points where the agent should pause and ask:<ul><li>Before any destructive action (delete, send email, deploy)</li><li>When confidence score drops below threshold</li><li>When the task branches into ambiguous territory</li></ul>A common pattern: flag uncertain steps with <code>requires_approval: true</code> and surface them via your UI/notification layer.<hr><h2 id="failure-modes-to-anticipate">Failure Modes to Anticipate</h2>Tool call hallucination: Model invents tool arguments that pass schema validation but are semantically wrong (e.g., a valid-looking but nonexistent file path). Add semantic validation layers beyond JSON schema.Infinite loops: Agent gets stuck in a retry loop after a tool error. Always implement circuit breakers.Context poisoning: Early tool results contain misleading data that biases all subsequent reasoning. Consider summarizing/filtering tool outputs before appending to context.Prompt injection via tools: If tool outputs include attacker-controlled text (web pages, user inputs), they can hijack agent behavior. Sanitize or sandbox tool outputs.<hr><h2 id="real-world-checklist">Real-World Checklist</h2>Before shipping an agentic workflow to production:<ul><li><code>max_steps</code> limit enforced</li><li>Token budget per run</li><li>All tool calls logged with inputs + outputs</li><li>Structured traces (OpenTelemetry or equivalent)</li><li>Human-in-the-loop gates for destructive actions</li><li>Graceful degradation when tools fail</li><li>End-to-end integration tests with adversarial inputs</li><li>Cost alerts when run cost exceeds baseline</li></ul><hr><h2 id="conclusion">Conclusion</h2>Agentic AI is genuinely transformative — but only when engineered with the same rigor as any distributed system. The model is one component among many; your observability, error handling, and cost controls are equally important.Start with the single-agent loop, prove value, then graduate to orchestrated multi-agent patterns as complexity demands. The frameworks are mature enough in 2026; the bottleneck is now engineering discipline.<hr>Further reading:<ul><li>Anthropic’s “Building Effective Agents” guide</li><li>LangGraph documentation on stateful agent patterns</li><li>OpenTelemetry GenAI semantic conventions</li></ul> <div>이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :) </div></div></div>

Dev Note

Introduction
The shift from chatbots to agentic AI is the defining change in applied ML in 2026. Instead of a single round-trip prompt → response, agentic systems plan multi-step tasks, call tools, spawn sub-agents, and self-correct — all autonomously. The promise is enormous; the failure modes are equally creative.
This guide distills hard-won patterns for teams moving agentic workflows from demos into production.
Photo by Possessed Photography on Unsplash
What Makes a Workflow “Agentic”?
A workflow is agentic when the model drives the control flow. Three markers:
Property
      Classic LLM Call
      Agentic Workflow
    
Control flow
      Deterministic, developer-defined
      Model-driven
    
Tool use
      Optional, single
      Required, multi-step
    
Scope
      Single turn
      Multi-turn or indefinite
    
The practical implication: bugs become emergent rather than deterministic. Your model can choose to call a tool you didn’t expect, in an order you didn’t anticipate, with arguments just outside valid range.
Architecture Patterns
1. Single-Agent with Tool Loop
The simplest production pattern. One model + a tool registry + a loop:
async def run_agent(task: str, max_steps: int = 20) -> str:
    messages = [{"role": "user", "content": task}]
    
    for step in range(max_steps):
        response = await llm.complete(messages, tools=TOOL_REGISTRY)
        
        if response.stop_reason == "end_turn":
            return response.content
        
        # Execute tool calls
        tool_results = await execute_tools(response.tool_calls)
        messages += [response.message, *tool_results]
    
    raise MaxStepsExceeded(f"Agent exceeded {max_steps} steps")
When to use: Tasks where a single model can hold full context — code generation, research summaries, data transformation.
Pitfalls:
No max_steps guard → runaway costs
Tool errors must feed back as messages, not exceptions
Context window exhaustion on long tasks
2. Orchestrator + Sub-Agents
For complex tasks, decompose into an orchestrator that plans and dispatches specialized sub-agents:
Orchestrator
├── ResearchAgent  (web search, summarization)
├── CodeAgent      (write, test, debug code)
├── ReviewAgent    (verify outputs, flag issues)
└── WriterAgent    (final synthesis)
The orchestrator never does work directly — it only delegates. Sub-agents are stateless and disposable.
class OrchestratorAgent:
    async def run(self, task: str) -> str:
        plan = await self.plan(task)
        results = {}
        
        for step in plan.steps:
            agent = self.agents[step.agent_type]
            results[step.id] = await agent.run(
                step.task,
                context={dep: results[dep] for dep in step.dependencies}
            )
        
        return await self.synthesize(results)
When to use: Long-horizon tasks, tasks requiring diverse expertise, workflows where sub-tasks can run in parallel.
3. Graph-Based Workflows (LangGraph / OpenAI Swarm patterns)
For workflows with conditional branches and cycles, model them as a directed graph:
Nodes = agent steps
Edges = state transitions (including conditional)
State = shared mutable context
This is now the dominant pattern in 2026 frameworks. It provides reproducibility (you can replay any execution) and observability (trace the exact path through the graph).
Production Concerns
Observability
Agentic traces are deep and branchy. Use structured spans:
@tracer.start_as_current_span("agent.step")
async def agent_step(messages, tools):
    span = trace.get_current_span()
    span.set_attribute("llm.model", MODEL_ID)
    span.set_attribute("messages.count", len(messages))
    span.set_attribute("tools.available", [t.name for t in tools])
    # ...
OpenTelemetry + a backend like Langfuse or Honeycomb gives you per-run cost, latency breakdown by step, and error attribution.
Cost Control
Agentic systems can burn tokens fast. Establish budgets per run:
class BudgetedAgent:
    def __init__(self, max_tokens: int = 100_000):
        self.token_budget = max_tokens
        self.tokens_used = 0
    
    def check_budget(self, tokens: int):
        self.tokens_used += tokens
        if self.tokens_used > self.token_budget:
            raise BudgetExceeded(
                f"Used {self.tokens_used} / {self.token_budget} tokens"
            )
Human-in-the-Loop
Not every decision should be autonomous. Identify approval gates — points where the agent should pause and ask:
Before any destructive action (delete, send email, deploy)
When confidence score drops below threshold
When the task branches into ambiguous territory
A common pattern: flag uncertain steps with requires_approval: true and surface them via your UI/notification layer.
Failure Modes to Anticipate
Tool call hallucination: Model invents tool arguments that pass schema validation but are semantically wrong (e.g., a valid-looking but nonexistent file path). Add semantic validation layers beyond JSON schema.
Infinite loops: Agent gets stuck in a retry loop after a tool error. Always implement circuit breakers.
Context poisoning: Early tool results contain misleading data that biases all subsequent reasoning. Consider summarizing/filtering tool outputs before appending to context.
Prompt injection via tools: If tool outputs include attacker-controlled text (web pages, user inputs), they can hijack agent behavior. Sanitize or sandbox tool outputs.
Real-World Checklist
Before shipping an agentic workflow to production:
max_steps limit enforced
Token budget per run
All tool calls logged with inputs + outputs
Structured traces (OpenTelemetry or equivalent)
Human-in-the-loop gates for destructive actions
Graceful degradation when tools fail
End-to-end integration tests with adversarial inputs
Cost alerts when run cost exceeds baseline
Conclusion
Agentic AI is genuinely transformative — but only when engineered with the same rigor as any distributed system. The model is one component among many; your observability, error handling, and cost controls are equally important.
Start with the single-agent loop, prove value, then graduate to orchestrated multi-agent patterns as complexity demands. The frameworks are mature enough in 2026; the bottleneck is now engineering discipline.
Further reading:
Anthropic’s “Building Effective Agents” guide
LangGraph documentation on stateful agent patterns
OpenTelemetry GenAI semantic conventions

Building Production-Ready Agentic AI Workflows: Architecture, Patterns, and Pitfalls

댓글