Agent vs Agentic

I’ve been lucky enough to have been hands on in building AI applications for the last several years. I’ve worked on over a dozen products and solutions that range from enterprise applications like Luster.ai to small specialized tools for teams I consult with.

One thing that felt very obvious to me early on, was that the quality of the response from an LLM was very closely tied to how much structure and focus you gave it. That’s why agentic has always made sense to me. More recently, the broader group of AI enthusiasts have been talking about AI agents a LOT… and I noticed that there’s quite a bit of confusion around agents vs agentic, so I put this guide together.

Before we dive in, I wanted to share this visual from Alexandre Kantjas that I happened to scroll across. It’s a great way to think about some of the trade offs in how you approach architecting your solutions.

Note: It looks like he’s got some cool courses on AI + Automation as well.

The Solo Performer: Single Agent AI

An agent is essentially a customized version of the model running under the hood. They usually have refined prompts, pre-determined tasks/capabilities, and a specific set of tools or functions they leverage to do the job. Think of something like custom GPTs, but with more unique capabilities like some of the agents on agent.ai. More than just "talking to Claude," these are focused tools with:

• Specific purpose: Each agent is designed for a particular job or domain (like Agent.AI's "Website Domain Evaluator” or "Business Model Validation")

• One-to-one model pairing: The agent is typically built around a specific LLM chosen for its strengths (speed, reasoning, specialized knowledge). While you can sometimes swap the model out, it tends to change the output format, quality, and consistency in a major way.

• Fixed system prompt: The agent operates within boundaries set by its system instructions. See my prompting guide.

• Dedicated tool access: The agent has access to specific tools chosen for its purpose e.g. web search, image generation, transcription services, web crawlers, etc.

For most straightforward tasks, this setup works beautifully. I can create a ChatGPT with specific knowledge and capabilities, iron out a good system prompt, and have something pretty darn useful — especially for repetitive tasks.

A Practical Hypothetical Single Agent Example

Let's say you want to build a personal task catcher that extracts your action items from Slack and adds them to your to-do list. At the personal level, this is pretty straight forward and you have multiple ways to handle the integration part e.g. Zapier, Slack MCP, or the API.

Here's a rough example of what the system prompt might look like:

You are a Task Extraction Assistant designed to analyze Slack conversations and identify action items assigned to the user. 

When processing Slack conversation data:
1. Identify explicit action items directed at the user (e.g., "Can you do X?", "@username please handle Y")
2. Identify implicit action items where the user has volunteered (e.g., "I'll take care of that")
3. Extract key details: task description, deadline (if mentioned), requestor, priority signals
4. Format each task in a standardized structure: [Task Description] | [Deadline] | [Requestor] | [Priority]
5. Ignore general discussion, questions, or actions assigned to others

After extraction, connect to the user's preferred task management system and add items accordingly.

Never create tasks that weren't explicitly or implicitly assigned in the conversation.

You would want to put more explicit detail in there to make sure it’s as helpful and usable as possible, but that’s it. You have one agent’s who’s job is to sort through all of the noise in Slack and turn it into an actionable list of things you actually have to DO.

But what happens when the requirements become more complex? What if you needed to capture progress updates and action items across multiple teams or projects?

You might be able to hack on the system prompt for this one agent for a while, or duplicate it and try and limit each one to the context of a project instead of a person, but I doubt it will be truly effective.

This is where agentic tends to shine.

The Orchestra: Agentic AI Systems

Agentic AI systems are fundamentally different. Instead of relying on a single agent to perform all tasks, they distribute work across multiple specialized agents that collaborate toward a common goal.

Think of it as the difference between a solo performer trying to play all instruments versus an orchestra where each member excels at their specific role.

Key elements of agentic systems include:

• Multiple specialized agents: Each agent focuses on specific responsibilities

• Orchestration layer: A system for facilitating the intended workflow and/or outcome.

• Communication protocols: How agents share information and outputs

• Evaluation checkpoints: Specific moments where work is assessed before proceeding

• Distributed tool use: Different agents can leverage different tools

This approach solves several fundamental limitations of single agents:

1. Breaking context limits: By distributing information across agents, you're no longer constrained by a single context window — and are less likely for the intended context to be used in the wrong way or at the wrong time.

2. True specialization: While single agents can be specialized in completing a task, agentic systems allow for even narrower focus allowing you to control the quality of each step in the process in a more granular way.

3. Parallel processing: Multiple agents can work simultaneously on different aspects of a problem e.g. researching new information on a topic while analyzing user-provided data.

4. Model flexibility: Different tasks can use different underlying models, allowing you to choose the “best model for the job” and also manage your costs.

5. Improved tool use: There’s a reason we have carpenters, masons, welders, etc. Using a tool and masterful tol use are very different things. Just look at anything I’ve cut with a skill saw.

Agentic AI Example: Team Task Coordination

Let's extend our earlier example to a team setting. Instead of just capturing your tasks, we want to process action items for an entire team, routing them appropriately based on content, urgency, and ownership.

This is where an agentic approach shines. Here's a rough example of what your “Orchestra” might look like:

Slack Monitor Agent

Purpose: Continuously monitors Slack conversations across channels-
Responsibilities:
- Extract all potential action items
- Capture relevant context and metadata
- Pass identified items to the Classifier Agent

Classifier/Triage Agent

Purpose: Determine the appropriate handling for each action item
Responsibilities:
- Analyze task nature and urgency
- Categorize as: personal task, ticket creation, meeting required
- Route to appropriate next agent based on classification

Ticket Creation Agent

Purpose: Create well-formatted tickets in project management system
Tools: JIRA API, GitHub Issues API
Responsibilities:
- Format task details into ticket structure
- Assign appropriate labels and priority
- Link relevant context and resources

Calendar Coordination Agent

Purpose: Schedule follow-up meetings when task ownership requires discussion
Tools: Google Calendar API
Responsibilities:
- Identify stakeholders needed for discussion
- Find available time slots
- Send calendar invites with context

The difference is striking. Instead of trying to jam everything into one agent, we've created a system of specialized components that each handle a specific part of the workflow.

Now, building all of those agents independently of each other wouldn’t do you much good, so you have to figure out how to get them to work together. Several frameworks and platforms have emerged to facilitate building these multi-agent systems and I don’t have a favorite to recommend yet.

Tools for Agentic AI

Individual agents are a bit easier to put together. Most providers have platform or developer experienced that allow you to grab your API keys and even build out agents:

• OpenAI/ChatGPT

• Anthropic/Claude

• Google AI Studio/Gemini

While you can build multiple agents that can work together through these tools, you really need that orchestration layer to configure and manage the hand offs between them.

Developer Orchestration Tools

Note: Most of these that started as developer tools are rolling out or plan to roll out UI based experiences as well. Some of the UI based experiences also have APIs and great developer resources.

LangGraph:

Built by LangChain, this Python framework enables you to create complex workflows between agents using directed graphs. Great for developers comfortable with Python and more complex implementations where you need more granular control.

LangGraph gets a little confusing because they have multiple products. LangSmith is for managing observability and evaluations, and LangChain for overall orchestration, model management, etc. These are all built and managed by LangGraph.

Then you have a handful of other projects and products that use “Lang” in the name and may even integrate, but aren’t directly associated or managed by LangGraph. For example, I really like UI based builder “LangFlow” and some of the engineers I work with like to handle prompt management and observability in Langfuse.

CrewAI:

A framework for orchestrating role-playing agents that collaborate to accomplish goals. CrewAI is a bit easier for technically savvy but less experienced developers who are relying more on assisted or vibe coding but understand sytem design and the basics of architecture. The workflows are less linear and the orchestration and decisioning is very outcome-focused. IMO Crew is a bit easier to get started with and conceptually makes more sense for a system design when you look at the capabilities of the foundation models right now.

CrewAI has a great developer ecosystem and integrates with most of the other big players. I’ve seen some really cool stuff built out with CrewAI and llamaIndex, and they leverage all of the “built in” tools that LangGraph offers.

Low-Code/Visual Editor Tools

• BeeStack: A visual tool for building and deploying AI agents with a drag-and-drop interface. Designed to be accessible to non-developers.

• Fixie.ai: Provides a visual interface for constructing agentic workflows with a focus on enterprise applications.

• Langflow: This is what I currently have set up on my personal computer but if I’m honest, I tend to sketch out my workflow and then “vibe code” it through Cursor or something like Replit.

New Trends to Watch

Beyond the orchestration platforms, there’s a budding ecosystem of new protocols and standards to help simplify “tooling” and even standardize how agents interact with each other:

Google's Agent-to-Agent (A2A) Protocol

Google recently launched the Agent-to-Agent (A2A) protocol, an open standard designed to facilitate communication between AI agents, regardless of who built them or what framework they're running on. While still new, A2A focuses specifically on agent-to-agent communication, creating a standardized way for agents to discover each other's capabilities, collaborate on tasks, and exchange information.

Anthropic's Model Context Protocol (MCP)

Anthropic's MCP has gained significant traction as a way to connect agents to APIs and data services. Where MCP focuses on structured tool use, A2A complements it by handling the communication between different agents.

Think of it this way: if MCP is the socket wrench (the tool interface), A2A is the conversation between mechanics (the agents) as they diagnose the problem.

I wrote about how I discovered it and how it’s been a game changer for me here.

Since then, Fleur hasn’t been doing much but I’ve found a lot of other cool MCP Servers like Merge like this one. I was at Google Next and the Anthropic team was pretty open about an MCP marketplace or directory being on their roadmap, so we’ll see how this plays out.

Recap: Pros & Cons: Choosing Your Approach

Have you experimented with agentic approaches in your products or workflows? I'd love to hear about your experiences, especially around the challenges of testing and evaluation. Drop a comment or reach out directly!

Looking to dig deeper into agentic design? I'm considering a follow-up piece diving into testing methodologies for multi-agent systems. Let me know if that would be valuable.