How I Chose an AI Agent Framework for QuickDesk

aovabo Alexander

2025 feels like the year AI agents finally left the lab and landed in the hands of real developers.

Everywhere I look, companies are experimenting. We see flashy tools connecting AI to browsers, and frameworks like CrewAI, LlamaIndex Workflows, and LangGraph popping up, trying to give engineers like me a structure to build with.

I work across IT, security, compliance, and privacy, so I was immediately drawn to the potential for agents to solve real business problems. Especially the constant friction around getting simple internal support. That’s what sparked my QuickDesk project.

But despite all the activity, truly useful agents haven’t yet broken through into widespread business or consumer use. That gap between potential and production made me want to find out what’s actually required to build something reliable.

To figure out the best path for QuickDesk, I decided to try out several of the newer frameworks that had emerged. I spent time with Mastra AI (TypeScript), CrewAI (Python), Smolgent (Python, from Hugging Face), LlamaIndex (Python and TypeScript), and most recently, Agno (Python).

Smolgent was fun. More like coding with the LLM as the main output.

LlamaIndex impressed me with its RAG pipelines and data integration tools.

Each framework taught me something different, and trying them helped clarify what I really needed for QuickDesk.

Before I could compare frameworks, I had to define what an "AI agent" really means. Based on everything I’ve read and tested, these agents aren’t just chatbots. They use a language model to drive a multi-step process. Most need memory to carry state, tools or functions to interact with systems, access to outside knowledge (usually with RAG), and some logic to plan or route decisions. Anthropic made a helpful distinction between predefined workflows and dynamic agents, which I found useful. It reminded me that agents only make sense when the task involves iteration, uncertainty, or multi-step reasoning.

That framing helped me see the building blocks more clearly: Models, Prompting, Tools and Skills, Memory and State, Knowledge (RAG), Workflows, and Evaluation. These became the lens I used to evaluate what would work best for my use case.

That’s when I began working more deeply with Agno (Python) for QuickDesk. A few things made it the right fit.

First, it’s Python-native, which aligns with the backend stack I had in mind and the libraries I needed.

Second, the Agno Workspace template gave me more than just a library. It came with an integrated FastAPI server, a PostgreSQL and PgVector setup using SQLAlchemy and Alembic, Streamlit for internal testing, Docker config, and AWS deployment scripts. That helped me move quickly from agent logic to a working product.

Third, I liked the clarity and modularity of Agno’s Python components. Defining an Agent meant configuring a class with parameters like description, tools, knowledge, memory, and storage. Adding tools was simple with Agno’s built-in kits or with your own Python functions using decorators. RAG setup was straightforward with built-in knowledge loaders and database components. And session persistence was handled cleanly through shared resource patterns in db/session.py.

Fourth, Agno gave me a good balance of control and visibility. I could shape behavior through detailed instructions and tune every part of the stack. The shared db engine for storage, embedder, and knowledge resources kept things clean and efficient.

Fifth, the built-in Streamlit UI was a great tool for debugging and testing. I could interact with each QuickDesk agent (IT, HR, etc.) in a clear interface, view tool calls, and load docs with a knowledge widget. For the frontend, Agno also provides a Next.js Agent UI, which I set up using npx. It visualizes tool calls and reasoning steps in a clean way that matches the kind of transparency I want users to feel when they interact with QuickDesk.

Considering common agent challenges like planning, consistent behavior, and tool reliability, Agno’s structure gave me a strong starting point. The instructions guide planning. Tools are structured and easy to swap or extend. Knowledge is handled by clear, well-documented components. I’ll likely experiment more with Agno’s reasoning features later, but the foundation is solid and gives me the control I want.

Ultimately, the best framework will depend on the kind of agent you’re building.

Mastra’s workflow engine is great for serverless apps in TypeScript.

CrewAI makes it easy to design multi-agent teams.

Smolgent (Python) introduced an interesting concept: code agents. Unlike other frameworks where the agent writes tool actions in JSON blobs, Smolgent lets the agent write actual code as its output. The difference is subtle but important. Code, after all, is what we already use to control computers. It's expressive, composable, and deeply embedded in LLM training data. You can’t nest or re-use JSON snippets the way you can write a function in Python. Smolgent leans into this by giving you a CodeAgent class out of the box, designed to run code outputs securely in sandboxed environments using tools like E2B. That made it feel more like giving the LLM a real programming environment rather than just a structured API to hit.

LlamaIndex stands out for advanced retrieval and data-focused tasks.

But for my goal of building a practical enterprise assistant like QuickDesk in Python, with clear building blocks and a real path to deployment, Agno gives me what I need.

Here's a list of every framework I’ve come across so far. I haven’t reviewed all of them yet. Some are full low-code platforms, others are lightweight libraries or experimental tools:

• CrewAI
• LangGraph
• LangChain
• SmolAgents
• LlamaIndex
• OpenAI Agents SDK
• Amazon Strands Agents SDK
• Google Agent Development Kit
• Azure AI Foundry Agent Service
• Camel AI
• n8n
• Agno
• AG2
• BabyAGI
• Langroid
• BondAI
• LLM Stack
• LaVague
• Lyzr Automata
• Praison AI
• Bee Agent Framework
• Sagentic
• AgentKit
• Agentflow
• Qwen Agent
• u7y
• Controlflow
• Cloudflare Agents
• AutoAgent
• Agience
• Agentok
• Dynamiq
• Agent GPT
• Inferable
• Fetch AI
• Mastra AI
• Microsoft Autogen
• Octo
• Letta AI
• Dapr Agent
• Floki
• AgentZero
• Dify
• Haystack
• SuperAGI
• AGiXT
• XAgent
• OpenAgents
• AI Legion
• Agent Protocol
• Agent.js
• BabyAGI
• Saplings
• Flowise
• Pydantic AI
• Upsonic
• Axllm

As you can see, this space is moving fast. Mastering even ten of these would be a lot. Some aren’t built for complex agentic systems. Some only support one language. CrewAI is Python. Mastra AI is TypeScript.

Choosing the right one depends on what you want the agent to do and how complex the task is. It also depends on what language you’re most comfortable with.

If you're building an agent and want help picking the right framework, or just need someone to build with you, I can help.