Note on Agent Definition: Throughout this blog, "agents" refer to autonomous execution systems. Anthropic provides an excellent exploration of what the definition of "agent" should be in their blog post. It's worth noting that at their core, many "agent" implementations are essentially orchestrated function calls.

SmolAgents defines agents as:

"Any efficient system using AI will need to provide LLMs some kind of access to the real world: for instance the possibility to call a search tool to get external information, or to act on certain programs to solve a task. In other words, LLMs should have agency. Agentic programs are the gateway to the outside world for LLMs."

SmolAgents System Prompt uses an extensive 200-line prompt for their Code Agent, indicating a highly structured and controlled approach to autonomy.

We can say that the level of autonomy is high within the task domain, but bounded by the supplied tools and rules.

AutoGen defines an agent as:

"A software entity that communicates via messages, maintains its own state, and performs actions in response to received messages or changes in its state. These actions may modify the agent's state and produce external effects, such as updating message logs, sending new messages, executing code, or making API calls."

Autogen System Prompt simply uses "You are a helpful AI assistant" as the base prompt inherited by all agent classes, suggesting a more flexible approach to autonomy.

The actual autonomy will depend on the specific configuration and usage of the agents within the application. An example is If the agent is used in a simple back-and-forth conversation with a user, its autonomy will be limited by the user's inputs and the predefined conversation flow.

It's important to note that these frameworks serve different missions: AutoGen focuses on multi-agent communication with features like Distributed Agent Runtime for multi-process applications, while SmolaGents focuses on code-centric problem solving with high autonomy within bounded task domains.

Now back to our comparison…

Comparison

AutoGen Strengths

• Seamless Jupyter execution support (an LLM that talks to a Jupyter server!!!)

• Flexible chat process configuration (roundrobin, etc.)

  • Robust multi-agent communication and orchestration

  • Termination criteria configuration for agents

• Successfully handled complex follow-up tasks (volatility calculation and regression modeling)

• Integration with LangChain tools

• Docker deployment support with "Docker out of Docker" approach

• Configuration process was fairly easy

SmolAgents Strengths

• Broader LLM support through LiteLLM integration

  • Support for all OpenAI-compatible endpoints and more

• Pre-built tools from Hugging Face hub

• Simpler import handling with pre-authorized imports for coe execution

• Built-in planning capabilities and step-by-step iteration

• Pre-configured memory in Code Agent

• Integration with LangChain and Anthropic MCP

• Easy attachment of additional data and arguments to agent queries

• Ability to leverage multiple data types (images, strings, etc.)

Limitations

AutoGen

• Limited to OpenAI-compatible endpoints

• Requires manual memory configuration

  • Manual configuration needed for multi-agent memory

• No built-in step iteration for agents

SmolaGents

• Code execution in remote environment is a third party servic, through E2B sandboxes

• No built-in multi-agent orchestration

• Manual implementation needed for E2B sandbox persistence

• Remote execution environment limits some functionality

• Steps iteration might add complexity for some tasks

Conclusion

AutoGen stands out as my preferred framework. Its termination criteria, seamless Jupyter integration and well-implemented function calling system make it particularly effective for complex analysis workflows.

I built an AI Data Scientist with Autogen and I ask it to analyse all sort of things for me!!

This comparison represents a limited experiment with significant room for expansion. As both frameworks continue to evolve, capabilities and limitations may change. The teams behind both frameworks are actively developing and improving their respective solutions.