The agent ecosystem moves fast enough that any guide written six months ago is already partially obsolete. This is our attempt to document what the landscape looks like right now — in early 2026 — with a specific lens: what works for small teams with limited budgets and no dedicated ML engineers?

We've organized this into four sections: the models that power agents, the frameworks that orchestrate them, the tools that connect them to the real world, and the infrastructure that keeps them running. For each, we give our honest take — what we actually use, what's overhyped, and what's worth watching.

Everything here is opinionated. Disagree? Good. Ship something and prove us wrong.

Section 1Models — The Brains Behind the Operation

You can't build an agent without a model. The good news: the gap between closed-source frontier models and open-weight alternatives has collapsed. The bad news: the choices can be paralyzing. Here's how we think about it.

The Closed-Source Tier S-Tier

If budget allows and you want the highest reliability with the least prompt engineering, the top API models are still the safest bet for production agents. Claude's Sonnet and Opus models excel at instruction-following and tool use — two things that matter enormously when your agent needs to reliably classify inputs and call functions. GPT-4o remains the versatile workhorse. Google's Gemini models offer the best price-to-performance ratio for high-volume, lower-complexity tasks.

At typical agent volumes for a small company (1,000–10,000 interactions/month), expect to spend $50–$300/month on API calls. That's less than a day of a junior hire's salary.

The Open-Weight Tier A-Tier

This is where it gets exciting. The open-weight models that can genuinely run production agent workflows on affordable hardware have arrived.

Model Strengths Best For Min Hardware
Llama 3.3 70B Strong reasoning, excellent tool-calling, robust instruction-following General-purpose agents, complex routing 48GB VRAM or quantized to 24GB
Mistral Large Fast, strong at structured output, good multilingual support Classification, data extraction, European markets API or 48GB+ VRAM
Qwen 2.5 72B Excellent coding, strong reasoning, competitive benchmarks Code agents, technical workflows 48GB VRAM or quantized
DeepSeek V3 Strong across the board, efficient MoE architecture Cost-sensitive production, high-throughput tasks API or significant VRAM
Phi-4 Surprisingly capable for its size, fast inference Simple classification, FAQ bots, edge deployment 8GB VRAM
Our pick for most teams

Use a closed-source API (Claude Sonnet or GPT-4o) for your first agent. Once it's stable, benchmark an open-weight model against your specific workload. Many teams find Llama 3.3 70B quantized hits 90%+ of the quality at a fraction of the cost. But don't optimize for cost until you've proven the agent works.

Local Inference: Who Should Bother?

Running models locally is compelling in theory — no API costs, no rate limits, full data privacy. In practice, it only makes sense if you process high volumes (10,000+ interactions/month where API costs get real), you have strict data residency requirements, or you already have GPU hardware sitting around.

For everyone else, APIs are simpler, more reliable, and cheaper at small scale. Running a 70B model on a rented A100 costs roughly $2/hour — that's $1,440/month if it's running 24/7. Compare that to $150/month in API calls for 5,000 interactions. The math doesn't work until you're processing serious volume.

The exception: small models like Phi-4 or quantized 7B variants run fine on a laptop GPU or even a Mac M-series with 16GB+ RAM. If your agent's task is simple enough (classification, FAQ lookup, template filling), a small local model can work beautifully.

Section 2Frameworks — Orchestrating the Agent

Agent frameworks are the most overhyped category in the stack. Here's the uncomfortable truth: most first agents don't need a framework at all. A Python script with an LLM API call and some if-statements will get you further than a misconfigured multi-agent orchestration pipeline.

That said, once your agent grows beyond a simple input → process → output loop, frameworks start earning their keep. Here's the current landscape.

LangGraph S-Tier

LangGraph has emerged as the most production-ready framework for stateful, multi-step agent workflows. Think of it as a graph-based state machine where each node is an LLM call, a tool invocation, or a decision point. It handles memory, branching logic, human-in-the-loop checkpoints, and parallel execution out of the box.

The learning curve is real — it's not something you'll master in an afternoon. But if your agent needs to handle complex routing (classify → branch → execute → validate → respond), LangGraph is the most battle-tested option. Their hosted platform (LangSmith) also gives you observability and debugging tools that are worth the subscription for production agents.

Use when

Your agent has 3+ steps, conditional branching, needs memory between interactions, or you need human-in-the-loop approval flows. Overkill for simple RAG bots.

CrewAI A-Tier

CrewAI's mental model is intuitive: you define "agents" with specific roles, give them tools, and assign them tasks in a workflow. It's the easiest framework to understand if you think about your automation as "a team of specialists working together."

It shines for multi-agent setups where different parts of a workflow benefit from different system prompts and tool access. A research agent feeds data to a writing agent which passes to an editor agent — that kind of pipeline. The downside is that multi-agent architectures are harder to debug than single-agent flows, and the overhead of multiple LLM calls per task adds up fast.

Use when

You have a workflow that naturally decomposes into distinct roles with different capabilities. Content pipelines, research-to-report flows, and complex data processing are sweet spots.

AutoGen B-Tier

Microsoft's AutoGen is powerful but feels enterprise-first. It handles multi-agent conversation patterns well and has strong integration with Azure services. If you're already in the Microsoft ecosystem, it's a natural fit. If you're not, the setup overhead isn't worth it for most small teams.

Plain Python / TypeScript A-Tier

Don't sleep on the no-framework approach. For straightforward agents — receive input, call an LLM with context, take an action, return output — a clean 200-line script is faster to build, easier to debug, and simpler to maintain than any framework.

You lose the abstractions for memory, tool management, and complex orchestration. You gain complete control, zero dependency overhead, and code that any developer can understand in five minutes. We've seen plenty of production agents at small companies that are just a well-structured Python file and a cron job.

Framework Decision Tree Is your agent a single input → process → output loop? → Skip the framework. Does it have 2–3 steps with branching? → LangGraph. Is it a pipeline of distinct roles? → CrewAI. Are you in the Microsoft ecosystem? → AutoGen. Are you unsure? → Start with no framework, add one when you hit a wall.

Section 3Tools & Connectors — Linking Agents to the Real World

An agent that can't interact with your actual business systems is just an expensive chatbot. The connector layer — how your agent reads email, updates your CRM, processes payments, posts to Slack — is where agents become genuinely useful.

MCP (Model Context Protocol)

Anthropic's open-source MCP has quickly become the standard for connecting LLMs to external tools and data. Think of it as a universal adapter: instead of writing custom integrations for every service, you connect MCP servers that expose tools in a standard format. There's a growing ecosystem of community-built MCP servers for popular services — databases, APIs, file systems, browsers.

For small teams, MCP's biggest win is reusability. Build or find an MCP server for Slack, and every agent you build can use it. The ecosystem is still maturing, so expect to write some custom servers for niche tools, but the trajectory is strong.

Vector Databases for RAG

Database Best For Hosting Our Take
ChromaDB Getting started, prototyping Local or embedded Easiest to learn. Fine for <50K docs.
Qdrant Production RAG, hybrid search Self-hosted or cloud Best balance of features and simplicity.
Weaviate Multi-modal search, complex schemas Self-hosted or cloud Powerful but heavier than most small teams need.
Pinecone Zero-ops managed search Cloud only Easy but vendor lock-in. Pricey at scale.
pgvector Teams already on Postgres Your existing Postgres No new infra. Good enough for most use cases.
Our pick

If you already run Postgres, start with pgvector — zero additional infrastructure. If you're starting fresh and want something purpose-built, Qdrant offers the best developer experience without enterprise complexity. ChromaDB for quick prototypes you plan to outgrow.

Automation Bridges

Not every integration needs to be code. For small teams, tools like n8n (self-hosted, open-source) and Activepieces (also open-source) let you wire agents to business tools using visual workflows. Zapier and Make work too if you don't mind the per-task pricing — though costs can surprise you at scale.

The pattern we see most: use n8n or similar as the "glue" layer that catches webhooks, routes data to your agent, and pushes the agent's output to the right destination. Your agent stays focused on the thinking; the automation layer handles the plumbing.

Section 4Infrastructure — Keeping Agents Running

Your agent needs to run somewhere, and you need to know when it breaks. Here's the minimal viable infrastructure stack.

Hosting

Observability

You must be able to see what your agent is doing. At minimum, log every input it receives, every LLM call it makes (including the full prompt and response), every tool it invokes, and every output it produces. When something goes wrong — and it will — these logs are the only way to diagnose the issue.

For tracing LLM calls specifically, LangSmith (from the LangChain team) and Langfuse (open-source) are the two standouts. Both let you see the full chain of an agent's reasoning, measure latency and cost per call, and identify where things break down. Langfuse can be self-hosted if you want full data control.

The Minimum Viable Agent Stack

If you're starting from zero and want the simplest path to a production agent, here's the stack we'd recommend:

The Build Anyway Starter Stack Model: Claude Sonnet API (or GPT-4o). Framework: None — plain Python. Knowledge: pgvector if you have Postgres, ChromaDB if not. Connectors: n8n for webhooks and routing, direct API calls for critical paths. Hosting: Railway. Observability: Langfuse (self-hosted on the same Railway project). Estimated monthly cost: $30–$200 depending on volume.

This stack will get you from zero to a production agent handling real workloads. It's not the most sophisticated setup — it's the one that gets you live fastest with the least risk of over-engineering yourself into a corner.

Once you're running, you'll quickly learn which component needs upgrading. Maybe your vector search isn't accurate enough (swap to Qdrant with hybrid search). Maybe your agent flow has gotten too complex for plain Python (add LangGraph). Maybe API costs are eating into margins (benchmark an open-weight model). Solve problems you actually have, not problems you imagine.

The landscape will look different in six months. We'll update this guide when it does. In the meantime, pick a stack, ship an agent, and iterate. The teams that win aren't the ones with the best architecture — they're the ones that deploy first and improve daily.