Agent-Based LLM Systems

While chained workflows (like those in LangChain) excel at linear processing, real-world applications often require dynamic decision-making and adaptive reasoning. This is where agent-based systems shine—by combining the power of LLMs with autonomous, tool-using components.

What Are Agents?

Agents are autonomous units that leverage LLMs to perform tasks through three core capabilities:

• Goal-Oriented Execution:
  Agents operate with a defined objective (e.g., “Generate PR report”) and autonomously determine how to achieve it.

• Tool Integration:
  Unlike static chains, agents can dynamically choose which tools to use (APIs, databases, calculators) based on context.

• Iterative Refinement:
  Agents evaluate their outputs and self-correct through feedback loops, often improving results without human intervention.

Why Use Agents?

1. Dynamic Decision-Making

Traditional chains follow fixed paths—if your PR analysis needs input from a documentation database halfway through, a chain requires preconfigured integration. Agents instead decide when to query external resources, making them ideal for unpredictable workflows.

2. Specialized Subagents

Complex tasks can be divided among role-specific agents:

• Analysis Agent: Focuses solely on code diff interpretation
• Validation Agent: Cross-checks against style guides
• Report Agent: Formats output for Slack/GitHub
  This division of labor mirrors how human teams operate.

3. Adaptive Problem Solving

When faced with incomplete data, agents can:

1. Identify knowledge gaps (“The diff references an undocumented API”)
2. Delegate to tools (“Search internal docs for ‘payment_service’”)
3. Incorporate new information autonomously

4. Failure Recovery

If an initial approach fails (e.g., an API call errors out), agents can:

• Retry with adjusted parameters
• Find alternative tools/methods
• Escalate to human operators

How Agents Work: The PR Report Example

Let’s revisit the PR report generator—now built with agents:

1. Orchestrator Agent receives the PR link.

   • Decides to:
     a) Fetch the diff via GitHub API
     b) Deploy Analysis Agent

2. Analysis Agent processes the diff:

   • Detects a potential security issue
   • Autonomously invokes a Security Linter tool
   • Incorporates linter results into findings

3. Report Agent structures the output:

   • Chooses Slack formatting
   • Adds emoji reactions to critical sections
   • Appends raw linter data as a collapsible attachment

This dynamic flow adapts to code complexity and findings without predefined steps.

smolagents: A Minimalist Agent Framework

The code example below shows how smolagents simplifies agent creation:

from smolagents import HfApiModel, ToolCallingAgent  
 
# 1. Define specialized agents  
analysis_agent = ToolCallingAgent(  
    tools=[CodeLinterTool],  
    system_prompt="Analyze PR diffs and identify risks"  
)  
 
report_agent = ToolCallingAgent(  
    tools=[SlackFormatter, GitHubMarkdown],  
    system_prompt="Generate platform-specific reports"  
)  
 
# 2. Autonomous execution  
orchestrator = HfApiModel("mistral-7b-instruct")  
report = orchestrator.run_agents(  
    "Generate PR report for https://github.com/...",  
    agents=[analysis_agent, report_agent]  
)  

Key smolagents features:

• Tool Registry: Agents automatically discover approved APIs/databases
• Context Passing: Output from one agent becomes input for others
• Cost Control: Limits LLM calls through constrained decision loops

When to Choose Agents Over Chains

Use Agents When	Use Chains When
Workflow paths are unpredictable	Steps are strictly sequential
External tool usage varies per input	Fixed toolset suffices
Self-correction is critical	Outputs require no refinement

Conclusion

Agent-based systems represent the next evolution in LLM application design. By enabling autonomous tool use and dynamic workflows, they handle complex, real-world scenarios that rigid chains cannot. Frameworks like smolagents lower the barrier to implementing these systems, offering:

• Better Problem Solving through adaptive reasoning
• Reduced Boilerplate with automatic tool integration
• Human-Like Flexibility in task execution

While chains remain ideal for simple, linear tasks, agents unlock new possibilities—from self-debugging code assistants to fully autonomous research systems. As LLMs grow more capable, agent frameworks will become essential for harnessing their full potential.