LEETLABS
§ 00 / FIELD NOTE
BY Said Betmurzaev · Founder, Leetlabs

AI agent development frameworks: an honest field guide

The agent-framework question is usually asked backwards. Teams pick a framework first and then look for a problem shaped like it. The order that actually works: decide what the system has to do, figure out how much autonomy that really requires, and only then reach for a framework, if you reach for one at all.

The one distinction that matters first

Before comparing frameworks, get clear on workflows versus agents, because most things people call agents are workflows and are better off staying that way. Anthropic’s engineering team drew the line cleanly in Building Effective Agents (December 2024): a workflow follows predefined code paths where an LLM does a step, while an agent dynamically directs its own process, choosing tools and steps at runtime. The difference is autonomy, and autonomy is a cost, not a feature. It buys flexibility and pays for it in unpredictability, latency, and token spend.

That same guide makes the point most framework marketing won’t: many useful patterns are a few lines of code against the model API directly, and you should start there. Prompt chaining, routing an input to a specialized handler, running calls in parallel, an orchestrator delegating to workers, an evaluator looping on a generator. If your problem is one of those, you may not need a framework at all, and adding one buys you abstraction you’ll later have to debug through.

The landscape, grouped honestly

When you do want structure, the ecosystem splits into two camps.

Provider-neutral frameworks work across model vendors and cover a broad range of workflow shapes:

  • LangGraph models an agent as an explicit graph of nodes and state. It’s the right pick when control flow matters and you want to see and constrain exactly how execution moves, including cycles and human-in-the-loop pauses.
  • CrewAI leans into role-based multi-agent setups, where you describe agents as collaborators with goals. It gets you to a working multi-agent demo fast; the tradeoff is less direct control over the underlying flow.
  • Microsoft’s AutoGen pioneered conversational multi-agent patterns and has since folded into a broader agent framework from the same team.

Provider-native SDKs trade portability for tighter integration with one vendor’s newest features. The OpenAI Agents SDK, released on 11 March 2025 under the MIT license as the production successor to the experimental Swarm project, is the clearest example, alongside the Claude Agent SDK and Google’s ADK. They mostly implement the same ReAct-style loop of reason, call a tool, observe, repeat. What differs is the host provider, the license and terms, and how deeply the SDK is wired into that provider’s stack.

Two things that decide more than the framework

License first, and this is the boring detail that sinks projects late. Most of the popular options are permissively licensed (the OpenAI Agents SDK is MIT, for example), but “open source” spans everything from MIT to copyleft, and the terms govern whether you can embed the framework in something you ship. Check the actual license file before you standardize, not after legal review.

Then tooling and evaluation, which matter more than the orchestration layer. An agent is only as good as the tools you give it and your ability to tell when it’s wrong. Most of the engineering in a production agent is in defining clean, well-described tools, handling failure and retries, capping loops so a runaway agent can’t burn your budget, and logging every step so you can reconstruct what happened. No framework does that part for you. It’s the actual work.

What this looks like in production

We build agents for production, which mostly means resisting the urge to make everything an agent. Our own platform, Vibehub, orchestrates multiple AI agents, and the lesson from running it is the unglamorous one: reliability comes from tight tool definitions, hard limits on autonomy, and observability, not from the framework logo on the box. Most of a system is deterministic workflow with a small, well-guarded agentic core where dynamic decisions genuinely earn their cost.

If you’re weighing this for a real build, our AI agent development work starts from that stance: use the least autonomy the problem needs, pick the framework the control-flow requirements point to, and spend your effort on tools and evaluation. The framework is the easy decision. Everything around it is the job.