Insights
A minimalist’s guide to agents
Designing LLM systems from the ground up
By
—
13
May
2025
Over the past year, thirteen23 has partnered with teams of all sizes, from early-stage startups to enterprise, to adopt large language models (LLMs) and explore agentic UX. Our biggest takeaway? The most effective systems rely on simple, focused patterns over complex frameworks or elaborate orchestration.
Anthropic’s research on effective agent design echoes this sentiment, highlighting that success with LLMs often hinges on reducing complexity, not increasing it.
The basics of “agentic” systems
Before we dive into the details, it’s useful to define what we mean by “agentic” systems. Agents represent the next major step in the evolution of large language models (LLMs). While agentic systems can take different forms, Anthropic distinguishes between two core types:
- Workflows: Systems where LLMs and supporting tools operate along predefined, structured paths.
- Agents: Systems where LLMs dynamically manage their own processes, actions, and tool usage.
Building on this distinction, it’s important to note that not all agentic systems involve direct interaction with an ‘agent.’
Implicit vs. explicit interactions
At thirteen23, we focus on the end-user experience, often differentiating between implicit and explicit orchestration to better align agent behavior with user needs.
Implicit orchestration happens behind the scenes. Agents act based on context and data in the background without direct user input. For instance, in a Retrieval-Augmented Generation (RAG) setup, the system automatically fetches and integrates data to enhance its output without intervention.
Explicit orchestration, by contrast, puts users in the driver’s seat. They guide workflows, set rules, and actively influence outcomes. This hands-on approach is ideal for use cases like content generation, where transparency and control are essential.
Ultimately, the choice between implicit and explicit orchestration should reflect user intent, weighing control, clarity, and automation. In practice, the most effective systems often blend both approaches, combining intelligent automation with meaningful user agency.
What makes Agentic software different?
The concept of orchestration marks a fundamental shift in software design, from programming step-by-step logic to coordinating thoughtful, autonomous behaviors.
Unlike traditional software systems, agentic software also lacks established best practices. It’s a fast-moving space, shaped by the evolving capabilities of frontier models.
This volatility poses challenges, but it also offers opportunities to rethink how we design. From our experience, these principles consistently guide successful agentic development:
- Prioritize user needs over technical capabilities
- Design the right level of abstraction for your goals
- Define clear, consistent interfaces for inputs and outputs
- Tightly manage synchronization and orchestration
- Use human-in-the-loop patterns to ensure quality and trust
With these in mind, let’s look at a few patterns that reflect our commitment to simplicity and thoughtful design.
Using simple, composable patterns
To tackle more complex tasks, agentic workflows rely on structured "chains" of actions. These chains guide LLMs through a sequence of smaller, focused steps, breaking down intricate problems to enable deeper reasoning and more reliable outcomes.
In keeping with this mindset, Anthropic recommends a set of core patterns that are both simple and powerful:
1. Prompt chaining
Sequentially breaking tasks into smaller, logical steps, where each step's output serves as input for the next.
Example flow
Writing marketing copy, then translating it into different languages, where each step maintains focus on a specific objective.
2. Routing
Classifying inputs and directing them to appropriate follow-up processes or LLMs based on their type or requirements.
Example flow
Customer service automation where technical issues route to a technical agent and billing inquiries to a financial agent, allowing for modular workflows.
3. Parallelization
Distributing a task across multiple LLM instances to either break tasks into independent parts or generate diverse responses for consolidation.
Example flow
Generating multiple product names using different creative criteria or distributing summarization tasks across sections of a large document.
4. Orchestration
A central LLM (orchestrator or “conductor") manages a workflow by dynamically assigning tasks to specialized worker LLMs.
Example flow
A research coordinator that delegates tasks like analysis, summarization, and fact-checking to different agents.
5. Evaluation
A two-agent setup where one LLM generates responses, and another evaluates or refines them in an iterative feedback loop.
Example flow
Content creation where one agent drafts while another reviews and suggests editorial improvements—leading to progressively better results.
These patterns help manage system complexity, improve modularity, and ensure responsiveness while keeping the end experience front and center.
A few parting thoughts
As noted by Anthropic, success in the LLM space isn’t about building the most advanced system; it’s about building the right one.
Leading with simplicity, and adding complexity only when it serves the user, leads to systems that are powerful, transparent, and easy to evolve.
Further Reading
- Building effective agents
- OpenAI cookbook
- The new language of experience design
- How LLMs are reshaping digital experiences
Curious about what an AI-driven future could look like for your software and your customers? Let's talk!
