AI Agents, Frameworks, and Why the Shift from Traditional Software Automation

Until very recently, most software packages and automation systems relied on hardcoded, conditional logic to determine the outcome of an operation. For example: if a certain condition is true, perform this action; if another condition is met, take a different action, and so on.

AI agents represent a fundamental shift in how we approach software development and automation. Here’s why.

Think of it with a human body analogy: the LLM (Large Language Model) is like the brain. While the brain can think and reason, it cannot interact with the environment or take action on its own. The human body has sensors—eyes, ears, nose, and touch—and effectors like hands, feet, and the tongue to act. An AI agent works similarly: it has tools that act as sensors (for example, performing a web search or reading from a database) and tools that can take actions (such as calling a REST API or triggering another agent). The LLM serves as the brain, reasoning and deciding which tool to use in any given scenario—without us having to hardcode the logic for every possible situation.

Most LLM vendors provide APIs to interact with their models directly. However, if our agent simply uses these APIs to perform specific actions based on logic hardcoded in our applications, we miss out on the greatest advantage of AI agents: letting the LLM itself decide which tools to invoke. Imagine a complex system with dozens or even hundreds of scenarios—do we really want to hardcode every combination? Of course not. We want the model to decide which tools to use to achieve the desired results, even if that means chaining multiple calls to different tools. This is something we want to avoid hardcoding.

Another benefit is the ability to give instructions to the agent on the fly, changing its behavior and logic dynamically. For example, you could provide a text file containing your investment strategy and criteria in plain English, and the agent can follow these instructions—without the need to rewrite, recompile, or redeploy your application.

This is where AI agent frameworks come in. They make it extremely easy to build agents: you write a piece of code, designate it as a tool, and attach it to your agent. These frameworks also provide context and memory for your LLM, the ability to evaluate results, and utilities to embed and query vector databases for Retrieval-Augmented Generation (RAG) purposes.

There are many excellent AI agent frameworks available, including:

• LangChain (the first major framework, but less commonly used for new projects)
• LangGraph (very production-ready, but somewhat opinionated)
• LlamaIndex (started as a RAG processor, now a full agent framework)
• Google Agent Frameworks
• Microsoft Semantic Kernel
• Microsoft Autogen
• CrewAI

Choose whichever suits your needs—they all offer the essential features mentioned above. For enterprises with vast amounts of data that need to ingest information from multiple sources and in different formats, I recommend LlamaIndex for its ease of use, RAG capabilities, strong documentation, and active community support. It is also free and open source, with a cloud offering if needed.

It’s worth mentioning that you should use the best LLM model you can afford from your chosen provider. In my experience, some of the more economical models from OpenAI haven’t performed optimally within agent frameworks, though performance ultimately depends on the specific requirements and complexity of your agent.

What’s your experience with AI agents? Have you implemented any of these frameworks in your organization? I’d love to hear about your challenges and successes in the comments below.