When to Use Agentic Systems

Agentic systems, where multiple AI agents collaborate through decision-making and handoffs, shine in specific scenarios but add operational complexity.

In this post, we'll explore the scenarios where agentic systems are most effective and the challenges you may face when using them.

Anthropic's guide on building effective agents has become the definitive resource in this space.

Their core advice? Start simple - use the most straightforward solution, and only add complexity when necessary. Agentic systems trade increased latency and cost for improved performance, so validate this tradeoff first.

From hands-on experience building production systems, agentic approaches prove most valuable when:

• Tasks require multiple steps: When a single LLM call can't complete the job (e.g., research → analysis → report generation)

• Specialisation matters: When different task aspects need tailored models/prompts (e.g., factual lookup vs. creative writing)

• Flexibility is critical: When step sequences can't be predetermined (e.g., customer service → technical specialist escalation)

• Domain complexity demands it: When knowledge needs compartmentalization (e.g., legal + medical expertise in insurance claims)

In my work with clients, optimised single LLM calls with retrieval augmentation often suffice. It's only when the complexity of the task is such that the agentic approach demonstrably improves outcomes that I recommend adopting agentic patterns.

Design Principles for Effective Agents

Now that we've established when agentic systems are appropriate, let's explore core design principles informed by Anthropic's research and hard-won implementation lessons:

Simplicity First

Implement the minimal viable system, then iterate. Follow the engineering maxim: "Make it work, make it right, make it fast" - in that order.

Atomic Responsibilities

Each agent should have one clear purpose. Like microservices, maintain a strict separation of concerns (e.g., "Medical Term Explainer" vs "Insurance Policy Parser").

Complexity with Cause

Add components only when metrics prove their value. Remember: More agents = more failure points + latency.

Transparent Operations

Make the active agent always apparent to users and engineers. Visual indicators (e.g., "[Medical Expert] Analysing scan results...") build trust and aid debugging.

Failure Resilience

Implement:

• Timeouts for all agent interactions

• Fallback routes for stuck workflows

• Input validation guards

• Test edge cases ruthlessly - especially handoff transitions.

Observability Focus

Track:

• Handoff success rates

• Agent-specific latency

• Error hot spots

• Completion metrics

Use this data to drive iterative improvements.

TL;DR

Agentic systems aren't inherently better; they're tools with specific strengths. The goal isn't to build the most sophisticated architecture using the latest flavor of AI patterns but the simplest solution for your users' needs.