Agentic Frameworks
This session evaluates leading Python-based agentic AI frameworks. The guide highlights LangGraph, Microsoft AutoGen, Strands Agents, and LlamaIndex as the most durable and pedagogically distinct tools for building intelligent systems. These frameworks are categorized into four schools of thought: graph-based workflows, multi-agent conversations, model-driven orchestration, and data-centric retrieval. Furthermore, the sources compare how these libraries implement core agent functions like memory, perception, and reasoning. The material also contrasts these code-first Python SDKs with visual automation platforms like n8n, while emphasizing emerging interoperability standards such as MCP and A2A.
The Four Philosophies of Agentic AI
Transcript
| Speaker | Text |
|---|---|
| Alex | You know, I spent the morning looking at the stack of research we have for today, and I honestly felt a bit like I was standing at the edge of a cliff. We’ve been tracking the AI space for a while now, but. What we’re looking at today feels different. It feels like we are past the point of just chatting with a bot. |
| Sam | We definitely are that novelty phase that is in the rearview mirror. We are in the architecture phase now. |
| Alex | Exactly. The sources today are all focused on agentic AI in Python, and I have to say, if you’re a developer or even just a technical manager trying to figure out where to place your bets for 2026. The landscape looks chaotic. You’ve got frameworks popping up left and right, all claiming to be the standard. It’s overwhelming. |
| Sam | It is the classic paradox of choice. You have these incredibly powerful large language models, right? But an LLM by itself is just a brain in a jar. It can think, it can write a poem, but it can’t do anything. It can’t book a flight. It can’t run code, and it certainly can’t navigate a corporate network without help. |
| Alex | And that’s our mission for this deep dive. We’re just going to list a bunch of tools and say good luck. We’re going to try to categorize the chaos. We have data here on the big 4 Python frameworks that are really defining how we build these, uh, digital employees. Lang Chain’s line graph, Microsoft’s Autogens, Strands agents, and Lamma |
| Sam | Index. And what’s fascinating to me, and what I hope you take away is that these aren’t just 4 different brands of the same cereal. They represent four completely different philosophies, 4 different schools of thought on what a digital brain should actually look like. |
| Alex | That’s what really jumped out at me from the reading. It’s not just a syntax decision, it’s a philosophical one. So here is the plan. We are going to skip the kitchen sink overview. I want to go graduate level on this. I want to understand which one fits, which problem, how they handle memory, because I’m, I know that is a nightmare to build from scratch and why I’d pick one over the other. I |
| Sam | love it. Let’s get into the weeds. |
| Alex | OK, let’s start with the definitions. We have these 4 contenders. Let’s look at the first one, the one that seems to be everywhere in the documentation, Lang graph. It’s from the Lang chain ecosystem. How do we even classify this? |
| Sam | If I had to put a label on Landgraf, I’d call it the orchestrator first school. The key word here is |
| Alex | control. Control, as in, I don’t trust the AI, |
| Sam | as in you don’t trust the AI to run the whole show blindly. Think of Landgraf as a micromanager in the best possible way. When you build an agent in Landgraf, you aren’t just telling the AI, go fix this. You are building a literal graph estate machine. |
| Alex | Walk me through that. When you say state machine, what does that actually look like for the developer sitting at the keyboard? |
| Sam | Imagine drawing a flowchart on a whiteboard. You have circles, which are your nodes. Maybe one node is an agent, another is a tool like a calculator or a database query. Then you draw lines, the edges connecting them. In La graph, you code that flow chart explicitly. You say, first go to node A, then check this specific condition. If it passes, go to node B. If it fails, loop back to |
| Alex | A. So the LLM isn’t really running the show here. |
| Sam | No, the graph is running the show. The LLM is just an actor inside one of those nodes. It’s essentially a decision-making. Engine that you plug into a rigid structure. |
| Alex | I can see why that would be appealing if you’re building something critical, but it also sounds like a lot of work. You have to wire everything up yourself. You do, |
| Sam | but the trade-off is determinism. You know exactly why the agent went left instead of right. OK, |
| Alex | so that’s the strict manager approach. Now, let’s pivot to the second contender, strands agents. The notes here say this is an open source SDK, but it’s backed by AWS. Is this just Amazon’s version of the same thing? |
| Sam | Not at all. Strands represents the model-driven school. It’s almost the polar opposite of Landgraf. How so? In Landgraf, you wire the connections. In Strands, you trust the model’s internal loop. It’s based on what we call emergent orchestration. You give the agent a goal, say, analyze the spreadsheet, and you give it a backpack of tools, |
| Alex | and you just let it go. You don’t tell it. First, open the file, then read row one. |
| Sam | Exactly. The model decides, OK, to analyze this, first I need to open the file. Now I see I need to read the columns. Now I’ll run a calculation. You didn’t program that sequence. The model figured it out on the fly based on the objectives and the tools you gave it. |
| Alex | Wait, isn’t that risky if the model’s deciding the loop, couldn’t it get stuck in a circle or do something totally unexpected? It |
| Sam | can, yes, that’s the price of autonomy. But for complex, dynamic tasks where you can’t predict every step in advance, it’s incredibly powerful. It’s the empowered employee model. You set the objective, but you don’t dictate the steps. All right, |
| Alex | I see the distinction. Moving to the third one. Microsoft AutoGen. I’ve seen some wild demos of this where it looks like multiple bots talking to each other. |
| Sam | That’s exactly what it is. AutoGen is the conversation-driven school. Their philosophy is that software development should look like a chat room. |
| Alex | A chat room, that sounds chaotic. |
| Sam | It can be, but think about how humans solve problems. If we have a complex project, we get a coder, a reviewer, and a manager in a room and we talk. Autogen simulates that. You create a coder agent and a reviewer agent. You put them in a loop. The coder writes a script, the reviewer looks at it and says, Hey, there’s a bug on line 4. The coder reads that message and tries |
| Alex | again. So the program logic is effectively just the transcript of their argument. |
| Sam | Precisely. The orchestration emerges from the message passing. It’s multi-agent collaboration by design. |
| Alex | That is a really distinct mental image, just bots bickering until the code works. OK. Number 4, lamma index. I know them mostly for data stuff, RAG pipelines, and that’s |
| Sam | their DNA. Lamma index is the data-centric school. If the others are about process or conversation. lambma index is about retrieval. Their agents aren’t just brains, they are brains sitting on top of a massive library. So |
| Alex | an agent here is defined by what it can read, |
| Sam | right? The focus isn’t on complex business logic loops like Landgraf. It’s on how to retrieve, read, and synthesize documents. It’s a research first approach. |
| Alex | OK, so just to recap the playing field before we go deeper, Landgraf is for workflow control, strands is for model autonomy. Autogen is for team conversation. And Lammy index is for data retrieval. |
| Sam | That’s the high level map. But the real differences, the stuff that will actually bite you in the rear if you choose wrong, appear when you look under the hood. Specifically, I want to talk about memory. Yeah, |
| Alex | let’s dig into that because LLMs are famously amnesiac. Every time you talk to them, it’s a blank slate. How are these frameworks actually solving that? Because if I’m building a travel agent, It needs to remember I like window seats. |
| Sam | Exactly. And the way they handle this reflects their philosophies perfectly. Take Landgraf. It uses a dual-tier approach. It has state and memory documents. What’s the difference? State is short term. It’s like a checklist for the current task. I’ve done step A. I’m waiting on step B. It tracks where you are in the graph, but then it allows for long-term storage, usually JSON documents in a database for things it needs to remember next week. |
| Alex | So it separates what am I doing right now from who is this user. |
| Sam | Exactly. It’s very structured, very database heavy. Now look at strands, because it’s built for production, often running on AWS infrastructure, it uses sessions like a web session. Very similar. Think of it like a browser cookie for your AI. The session persists the history and the state across runs. It’s a bit more set it and forget it. You don’t have to manually manage the database entries as much as you might in Landgraf, |
| Alex | OK. And Autogen. If it’s just a chat room, is memory just the chat log? |
| Sam | Basically, yes, they use conversation buffers. Memory is just scrolling up. |
| Alex | That feels incredibly inefficient. Eventually you run out of context window, right, where it gets too expensive to feed the whole history back in. You |
| Sam | absolutely do. It’s surprisingly low tech in its default state. For long-term memory, developers often have to bolt on their own database solutions. But for the task at hand, that rapid back and forth between a coder and a reviewer, that scroll up context is usually exactly what you need. They aren’t trying to remember your birthday. They’re trying to remember the bug from 3 messages ago. |
| Alex | Fair point. And I assume lemma index does something fancy with vectors. |
| Sam | Of course. They treat memory as a search problem. Short term is chat history. But long term facts are stored as vector blocks. |
| Alex | Break that down for me. |
| Sam | Instead of just saving a file, they index it. So if the agent needs to remember a specific policy from a conversation 3 weeks ago, it doesn’t just remember it. It performs a semantic search on its own memory database to retrieve the relevant block. |
| Alex | So it’s Googling its own brain. |
| Sam | That’s a great way to put it. |
| Alex | This leads me to another question about how they interact with the world. You mentioned perception in the notes. I usually think of perception as computer vision. Cameras and stuff, is that what we’re talking about partially, |
| Sam | but it’s broader. It’s about how the agent gets input in Landgraf and strands. Perception is tool driven. If you want the agent to see an image, you have to explicitly give it an image reader tool. You have to hand it the eyes. It’s manual. Yes, but in Autogen, perception is conversation anchored. You drop an image into the chat, and the agents see it as just another message in the stream. |
| Alex | It feels more natural. |
| Sam | It is. And Lamey index. It sees the world as documents, a PDF, an invoice, a web page. Those are the atoms of its universe. It parses the world into text chunks. |
| Alex | I’m starting to see why you can’t just pick one at random. The architecture dictates what the agent is actually capable of. So let’s bring this down to earth. If I’m listening to this and I have a specific problem to solve, which one do I pick? Let’s look at the killer app for each. Sure, |
| Sam | let’s start with Landgraf. Its killer app is regulated, compliance heavy workflows like banking, exactly. Imagine a loan approval process. You have strict laws. You cannot have the AI hallucinating a new step or skipping a background check just because it felt creative, right? |
| Alex | You can’t have the AI say, I felt like this guy seemed nice, so I skipped the credit check. Precisely. |
| Sam | In Landgraf, you design the graph so that step A must lead to step B. It gives you auditability. If something goes wrong, you can point to the exact node in the graph that failed. It’s safe. |
| Alex | So if your boss says, explain why the AI did this, you want line graph. |
| Sam | Yes. Now, swap that for strands. Strands is fantastic for rapid prototyping and agent as a service. Think of a math assistant or a science tutor. |
| Alex | Why strands for that and not Lang graph? |
| Sam | Because in tutoring, you don’t know the steps in advance. If a student asks a tricky calculus problem, the steps change based on the problem. You want the model to figure out the plan. Strand’s internal loop allows the model to reason. OK, first I need to derive this, then I need to calculate that. You don’t want to wire a rigid graph for that. You want the model to |
| Alex | lead. It feels more AI native. OK, what about the chat room, Autogen? Collaborative |
| Sam | coding and simulation. The classic example is the coder plus reviewer loop we talked about. But think bigger, think simulation. You could set up an agent representing a user and an agent representing tech support and have them talk to test your training manuals. That’s |
| Alex | clever. You’re simulating social dynamics. |
| Sam | Exactly. The logic lives in the |
| Alex | dialogue. And finally, Lemay index. |
| Sam | Knowledge heavy RA. Let’s say you are a law firm. You have 10,000 PDFs of case law. You need a research agent that can synthesize an answer citing specific precedents. Lamia Index is built for this. It knows how to query the data, cite sources, and synthesize. If your problem is, I have too much data and I need answers, you start there. |
| Alex | OK, that clarifies the landscape significantly, but I want to pivot to the graduate level stuff we promised. We’re hearing a lot about systems that use multiple agents. |
| Sam | This is where we get into multi-agent architectures. And again, the approach varies wildly. |
| Alex | I assume Landgraf handles this hierarchically. Yes, |
| Sam | Landgraf uses graph orchestration. Imagine a supervisor node, a boss that routes work to worker nodes. It’s very structured, like a corporate org |
| Alex | chart, and Autogen is the peer to peer version, |
| Sam | right? The group chat. It’s peers sitting around a table, but strands introduces something interesting called swarm patterns. |
| Alex | Swarms. That sounds a little ominous. |
| Sam | It’s actually very efficient. It allows for self-organizing teams. You might have a dispatcher agent that hands a task to a specialist who might hand off a subtask to another specialist. It’s fluid, not rigid like the graph, but not as chaotic as the chat room. |
| Alex | But here’s my question. If I build a swarm in strands and you build a graph in land graph, are we stuck in our own walled gardens? Or can these things talk to each other because in the real world companies use 10 different tools. |
| Sam | That is the billion dollar question. And it brings us to the most important acronyms in this space right now, MCP and A2A. |
| Alex | Let’s break those down, MCP. Model context protocol. I’ve seen this mentioned everywhere. Is it just an API? |
| Sam | Think of MCP as a USB port for AI agents. A USB port. Before MCP, if I wanted my agent to connect to Google Drive, I had to write custom code. If I wanted it to connect to Slack, more custom code, it’s like having a different charging cable for every device. NCP standardizes that. It’s a capability layer. So |
| Alex | if a tool like a database or a calendar is NCP. Compatible. Any agent can plug into it. |
| Sam | Theoretically, yes. And here’s the implementation detail that matters. Strands is MCP native. It has a built-in client. It speaks MCP out of the box. And the others. Autogen and Lamma Index use adapters. They can use MCP tools, but they have to translate them into their own formats first. It’s a bit clunkier. |
| Alex | So Strands has an edge on connectivity right now. Now, what about A2A? Agent to agent. |
| Sam | If MCP is about connecting an agent to a tool, A2A is about connecting an agent to another agent. It’s the orchestration layer. OK, so |
| Alex | this answers my wall guarding question. Exactly. |
| Sam | Imagine you build a great researcher agent in Landgraf, and I build a great writer agent in Autogen. A2A lets them talk to each other across the network. |
| Alex | That’s huge. That breaks down. The silos. It does. |
| Sam | And again, Strands and AG2, which is the successor to Autogen, have native A2A support. They’re ready for this distributed future. Landgraf currently relies on adapters, essentially wrapping agents as HTTP servers to talk to the outside world. It works, but it’s not native in the same way. |
| Alex | I want to touch on one more conceptual debate before we move on. The notes mention a distinction between tools and skills. Is that just semantics? It sounds like marketing |
| Sam | fluff. It sounds like semantics, but it affects how you build. Generally, a tool is the hands, an API, a calculator, a function. A skill is the mental muscle, a prompt, a behavior, a way of thinking. |
| Alex | Can you give me a concrete example? Sure, |
| Sam | a calculator is a tool. Knowing how to break down a word problem into an equation so you can use the calculator. That’s a skill. |
| Alex | And do the frameworks treat them differently? |
| Sam | Most blur the lines. They just bundle everything into the prompt context. But Llama Index explicitly separates them. They have MCP tools, but they also have local skill folders. So |
| Alex | in Llama Index, you can essentially upload a skill to an agent, like you’re loading a program into the Matrix. I know kung |
| Sam | fu. That’s a great analogy. Yes, you are modularizing the reasoning strategy separate from the external API |
| Alex | calls. Now we can’t talk about orchestration without mentioning the low code elephant in the room. We see it everywhere. People are building incredible workflows visually. How does that fit in with these Python frameworks? Are they competitors? |
| Sam | Not really. They are complementary. Think of NAN as a workflow level orchestrator. It’s the glue. It’s fantastic for things like when an email comes in, trigger this process, and then post a Slack. It handles the pipes, right? But the Python frameworks slang graph, Autogen are the agent engines. They handle the complex reason. loop. You wouldn’t want to build a complex iterative reasoning loop visually in N8N. It would look like a bowl of spaghetti. So |
| Alex | the pro move is to combine them. Exactly. |
| Sam | You use NAN as the trigger and the delivery mechanism. But for the heavy lifting, NAN makes a call to a Python microservice running a Lang graph or Autogen agent. The Python agent does the thinking, and NAN handles the logistics, the |
| Alex | synergy approach. I like it. So let’s wrap this up. We’ve covered a lot of ground. We’ve got the orchestrator Lane Graf, the model driven strands, the conversationalist, Ottogen. And the librarian Lammy index. And |
| Sam | that’s the key takeaway. Safety and learning in AI aren’t about training models anymore. We aren’t tweaking weights in a neural network. We are tweaking orchestration. We are adjusting feedback loops. We are building guardrails tailored to these specific architectures. |
| Alex | It’s engineering, not just data science, |
| Sam | precisely. And if I can leave you with one final thought, we spent a lot of time comparing frameworks, but as protocols like A2A and MCP mature. I think the specific framework you choose might matter less than you think. |
| Alex | How so? Because right now it feels like the most important decision, |
| Sam | because we are moving toward a network. If a Landgraf agent can seamlessly call a strands agent, which can seamlessly query a lamma index data store, then the brain isn’t in the code anymore. The intelligence is in the network of agents. That’s a wild. Thought. The deep dive of the future won’t be about which framework handles memory best. It’ll be about how to design the social network of your digital workforce. |
| Alex | The network is the computer all over again. History rhymes. Well, on that note, we’re going to wrap it up. I hope this helps you navigate the menu of digital brains. Thanks for listening to the Deep Dive, and we’ll catch you in the next one. |
Python Fameworks
LangChain / LangGraph https://www.langchain.com/langgraph
- Role in lecture: The “full‑stack, general‑purpose” baseline.
- Why it’s essential: Broadest ecosystem, tooling, RAG, and strongly opinionated workflows; LangGraph now serves as the de facto standard for stateful, graph‑based, multi‑step agents. Frequently cited as the center of the Python agentic landscape.
Microsoft AutoGen https://microsoft.github.io/autogen/stable//index.html
- Role in lecture: Multi‑agent conversation and orchestration.
- Why it’s essential: Focuses on agent‑to‑agent collaboration, self‑reflection, and human‑in‑the‑loop workflows. Frequently listed among the top agentic frameworks for production‑grade multi‑agent systems.
Strands Agents https://strandsagents.com/latest/
- Role in lecture: Model‑first, observable, production‑grade SDK.
- Why it’s essential: Lightweight, model‑agnostic, and explicitly designed for observable, tool‑driven agents, with strong AWS‑style telemetry and multi‑model support. Often highlighted as a good fit for production‑like, provider‑flexible agents and is mentioned in side‑by‑side comparisons alongside LangGraph, AutoGen, and Pydantic‑based frameworks.
LlamaIndex (Agents) https://developers.llamaindex.ai/python/framework/
- Role in lecture: Data‑centric and retrieval‑driven agents.
- Why it’s worth adding: LlamaIndex is increasingly treated as a first‑class “agent framework” layer atop its RAG infrastructure, with built‑in agent modes and tools for interacting with structured/unstructured data. It’s consistently ranked among the top agentic frameworks for data‑heavy, knowledge‑agent applications.
No/Low-Code Famework
- N8N AI https://n8n.io/
- Role in lecture: Visual, workflow‑centric agent orchestration.
- Why it’s worth mentioning: n8n is a source‑available automation platform that adds AI agent nodes to its drag‑and‑drop workflow builder, making it easy to connect LLM‑based agents with hundreds of existing SaaS and data integrations. It excels at production‑ready orchestration of clearly defined, event‑driven workflows (email, CRM, ticketing, data pipelines), where agents act as steps in a larger business process. Compared to Python‑native frameworks, n8n focuses less on deeply autonomous, stateful agents and more on tying agents, tools, and traditional automation together in a visual environment, including multi‑agent patterns where an orchestrator agent calls specialized sub‑agents and MCP‑based tools.
Code Examples:
- Examples of Agentic Frameworks Agentic RAG with simple text document as knowledge source (LangGraph, Strands, AutoGen, LlamaIndex)
- Examples of n8n Demonstration of using n8n built-in AI Agent