# What AutoGen's maintenance mode teaches FDEs about picking frameworks

> Microsoft now steers new users to its Agent Framework, so ask first who will maintain a tool after you leave, then whether security will approve it.

Original: https://fdetimes.net/en/tools/autogen-maintenance-mode-choosing-multi-agent-framework/

Microsoft then adds that new users should start with Microsoft Agent Framework.

Picture a client with an agent proof of concept built on AutoGen last year, who now wants it in production. The first thing you need to tell them has nothing to do with prompts or agent architecture.

You have to tell them that the framework they depend on is now in maintenance mode, and that Microsoft itself recommends a different product for new projects.

For an FDE, choosing a multi-agent framework is a matter of due diligence, not taste. The client has to live with the choice long after you leave. This article therefore follows the order in which a client's security team or CTO will ask their questions.

## Who still maintains it?

AutoGen is the clearest lesson. The code remains under the MIT licence, so the client can still use and fork it. Maintenance mode does not mean the project has vanished. But when Microsoft itself tells new users to start with Agent Framework, a new project should think hard before building on AutoGen.

Old documentation can mislead you too. Microsoft Research's AutoGen page still presents v0.4 as a complete redesign with an asynchronous, event-driven architecture. The page carries no date and says nothing about Agent Framework, so if you read only that page you could easily assume AutoGen is still the default choice for new projects.

There is also a naming trap. smol.ai is a different company, building a continuous fine-tuning platform; it is not Hugging Face's smolagents. Getting the name wrong in an architecture document sent to a client is the quickest way to lose credibility.

## What does each framework promise?

Once you know which frameworks are still recommended for new projects, the next step is to read how each describes itself. That is their promise, not something yet verified.

| Framework | Self-positioning | Worth checking | Licence |
|---|---|---|---|
| CrewAI | Agents, crews, flows; claims production readiness from day one | Flows with start/listen/router, state persistence, resuming long workflows | Verify yourself |
| AutoGen | Async, event-driven architecture (v0.4) | In maintenance; Microsoft points to Agent Framework | MIT (code) |
| Agno | Framework plus runtime (AgentOS) for agent platforms | Uses your own database, runs on any cloud container | Apache-2.0 |
| smolagents | Agent core of roughly a thousand lines of code | CodeAgent, sandboxing via Modal, Blaxel, E2B, Docker | Verify yourself |

CrewAI says guardrails, memory, knowledge and observability are all built in. That helps with speed, but it means accepting CrewAI's definitions of those things. smolagents goes the other way, keeping its abstractions as thin as possible over raw code.

## A test case: a document-processing agent for a bank

Suppose the client is a bank that wants an agent system to read loan applications, look up internal data and pass the case to a human reviewer. Four requirements are on the table, and each pushes you in a different direction.

The first comes from the security team: agents must not run code on production servers. Here smolagents has the edge, because CodeAgent writes its actions as code and can run them in a sandbox such as Docker or E2B. You can walk into the security review with a concrete answer.

The second is an approval process that lasts several days while waiting for signatures. CrewAI Flows suits this, because it persists execution state and can resume long workflows. The third is that data must not leave the bank's infrastructure. Agno emphasises exactly that: your database, your cloud container.

The last is that models must run internally. smolagents supports models on the Hub, OpenAI or Anthropic via LiteLLM, and locally run Transformers or Ollama. Going by the documentation alone, each framework emphasises a different subset of these requirements, so your job is to show the client clearly what they are prioritising and what trade-offs they accept by choosing one.

**Key point:** Don't ask which framework is strongest. Ask which of the client's requirements are non-negotiable, then eliminate.

## The limits of evaluating from documentation

Every strength listed above is self-reported by the projects. "Production-ready from day one" is just a slogan until you run a workflow that fails halfway through and see whether it actually resumes. The comparison table is a starting point, not a conclusion.

That is why a small verification step matters more than any review. A two-day spike for each shortlisted framework, run against a single real client use case, is worth more than many meetings.

## What to learn first?

If you are starting out, learn smolagents first. A core of roughly a thousand lines is small enough to read end to end, and, simplifying somewhat, you will see that an agent is essentially a loop: call the model, run an action, read the result. Then move on to CrewAI Flows to learn how to manage state and long-running workflows.

On your CV, don't just list framework names. Write a line such as "evaluated four agent frameworks on maintenance, licence and sandboxing requirements; selected the approach for system X". When reading FDE job descriptions, look for terms such as security review, on-prem or self-hosted, because those are exactly the criteria you have just practised.

Frameworks will keep changing; AutoGen is proof. The skill of reading a README as the person accountable for the system is one you can take to any project.

**Try this week:**

- Open the README of each framework you use and record its maintenance status and licence in a one-page table
- Run a smolagents CodeAgent in a Docker sandbox with a model running locally via Ollama
- Build a three-step CrewAI Flow with start/listen/router, deliberately stop it midway, then check whether it resumes

## Sources

- [CrewAI Documentation](https://docs.crewai.com/)

- [GitHub - microsoft/autogen](https://github.com/microsoft/autogen)

- [AutoGen - Microsoft Research](https://www.microsoft.com/en-us/research/project/autogen/)

- [GitHub - agno-agi/agno](https://github.com/agno-agi/agno)

- [smolagents (Hugging Face docs)](https://huggingface.co/docs/smolagents/index)

- [smol.ai - Continuous Fine-tuning Platform for AI Engineers](https://smol.candycode.dev/)
