Demystifying Agentic AI: What Are Agents, Their Core Components, and Building With (or Without) Frameworks

Agentic AI is buzzing right now, but if you ask five experts what an “agent” is, you might get six answers. At its core, an AI agent is a system powered by large language models (LLMs) that can autonomously handle tasks by making decisions, interacting with the world, and adapting on the fly. One useful definition I’ve come across is: AI agents are programs where LLM outputs control the workflow. This emphasizes how agents go beyond simple chatbots — they do things based on reasoning.

In practice, something gets labeled an “agent” if it involves one or more of these elements:

1. Multiple LLM calls: Breaking a problem into steps, where each step might involve querying an LLM.
2. LLMs with tool-using abilities: Giving the model access to external functions, like searching the web or querying a database.
3. An environment for LLM interaction: A setup where models can observe, act, and get feedback from the real world or a simulated space.
4. A planner to coordinate activities: Something (code or another LLM) that orchestrates the flow.
5. Autonomy: The system decides its own path, rather than following a rigid script.

The lines blur because even simple setups can feel “agentic” if there’s a hint of decision-making. For instance, is a chain of prompts that lets an LLM pick a topic and then generate content an agent? It’s debatable, but it introduces autonomy. To make sense of this, let’s borrow a framework from Anthropic (the folks behind Claude AI), who split agentic systems into two broad categories: workflows and true agents.

Workflows vs. True Agents: A Key Distinction

Anthropic draws a line between structured “workflows” and more flexible “agents.” Workflows orchestrate LLMs and tools through predefined paths — think of them as assembly lines where the steps are fixed, even if LLMs handle the heavy lifting. Agents, on the other hand, let LLMs dynamically steer their own processes, deciding tool usage and adapting in real-time.

This distinction helps when designing systems. Workflows are great for reliability in production, while agents shine for complex, unpredictable problems. But honestly, the boundary is fuzzy — some workflows can feel pretty autonomous!

The Five Common Workflow Design Patterns

Prompt Chaining: Decompose a task into a sequence of fixed subtasks, each handled by an LLM call. It keeps things on rails by framing each prompt precisely, improving accuracy.

Routing: An LLM classifies the input and routes it to a specialized model. Separation of concerns — route to experts for better results.

Parallelization: Code breaks a task into subtasks run concurrently by multiple LLMs, then aggregates results. Speed up by handling parts simultaneously. Tasks can be identical (e.g., run the same query three times and average) or different.

Orchestrator-Worker: An LLM (orchestrator) dynamically breaks down a complex task, assigns to worker LLMs, and synthesizes results. More dynamic than parallelization since an LLM decides the breakdown.

Evaluator-Optimizer: One LLM generates a solution, another evaluates it, looping until it’s good. Boosts reliability — key for production where accuracy matters. Example: Content creation where the evaluator checks for errors, sending back for revisions. I use this often to validate outputs.

True Agent Patterns: Open-Ended and Flexible

Agents flip the script — they’re not fixed paths but looping systems with feedback.

• Flow: Human/Environment Input → LLM → Action on Environment → Observation/Feedback → Repeat until done → Output.

Here, the LLM plots its own course, deciding actions and when to stop. It’s powerful for open problems (e.g., an agent controlling smart home lights based on user requests and sensor data). But drawbacks include unpredictability: How long will it run? What will it cost? Will it even finish?

Mitigations? Monitoring (trace interactions) and guardrails (software constraints to prevent runaway behavior). We’ll build these in future posts.

Core Components: Resources vs. Tools

Agents aren’t just LLMs — they need “equipment” to thrive.

Resources: Boosting Knowledge with Context

Resources are about arming your agent with extra info to enhance its expertise. It’s as simple as injecting relevant data into prompts. For a customer support agent at an airline, stuff ticket prices into the prompt so it can reference them accurately.

But it gets fancier: Use techniques like Retrieval-Augmented Generation (RAG) to fetch only relevant context dynamically (e.g., via vector search). This avoids overwhelming the LLM. Resources make agents smarter without changing their core behavior — think of it as giving them a cheat sheet.

Tools: Enabling Actions and Autonomy

Tools are where the magic happens: They let LLMs do things beyond generating text. Examples include querying databases, sending emails, or controlling devices.

Under the hood, it’s not as mystical as it sounds. You prompt the LLM with available tools (e.g., “You can use ‘fetch_ticket_price’ for city X”). It responds in structured format (like JSON) indicating which tool to call and with what args. Your code executes it (e.g., via an if-statement), gets the result, and feeds it back to the LLM.

Example: In a chat with an LLM acting as an airline agent, ask “How much for a flight to Paris?” It might respond: {“tool”: “fetch_ticket_price”, “city”: “Paris”}. You run the tool, get “$500,” and reprompt the LLM with that info for a final answer.

Tools grant true autonomy, but remember: It’s your code bridging the gap — no direct LLM-to-world connection.

No Framework vs. Framework: How to Build Agents

You don’t need a framework to create agents — custom code works fine, especially for simple setups.

• No Framework Approach: Use raw LLM APIs (e.g., OpenAI’s client). Prompt chains, tool calls via JSON parsing, and loops in Python. Pros: Lightweight, full control. Cons: Reinventing wheels for monitoring/guardrails. Great for local LLMs or quick prototypes — connect to models like Gemini or even run them on your machine.
• Framework Approach: Tools like LangChain, CrewAI, or OpenAI SDK handle orchestration, tool integration, and tracing. Pros: Faster development, built-in guardrails. Cons: Learning curve, potential overhead. We’ll compare these in upcoming examples.

Start simple: No framework for basics, then scale with one.

Wrapping Up: The Road Ahead

Agentic AI blends structure (workflows) with freedom (agents), powered by resources and tools. While powerful, it demands handling uncertainty through smart design.

In the next posts, we’ll build real agents (e.g., research bots, coding assistants) across frameworks. Stay tuned — follow for updates. Let’s demystify AI together!

Thanks!