The Stack
The Best Open-Source MCP Gateways for Self-Hosted Agents
Five real, self-hostable gateways that put one endpoint in front of many MCP servers — and why the stateless spec is about to change what a gateway is even for.
The Stack
The Stack
The Best Open-Source Frameworks for Training AI Agents with Reinforcement Learning
Seven real, self-hostable RL frameworks for post-training tool-using agents — and why the one you pick should be decided by the environment, not the algorithm.
The Stack
Semantic Caching vs Prompt Caching: Which One Actually Cuts Your LLM Bill (and Which Can Return a Wrong Answer)
They both have 'caching' in the name and both promise to slash your token spend, but they cache different things at different layers with different safety profiles. One's worst case is a cache miss. The other's worst case is a confidently wrong answer.
The Stack
RL Frameworks for Training AI Agents: SkyRL, Agent Lightning, RLinf, AgentGym-RL
Everyone ships the same PPO. This year's agent-RL frameworks all fight over the one thing that's actually hard — the rollout.
The Stack
The Self-Hosted AI Gateway: 7 Open-Source Proxies That Became the Agent Control Plane
The 'AI gateway' stopped being a cost-tracking load balancer and turned into the policy layer for autonomous agents — and that shift is why the newcomers are all written in Go and Rust, benchmarking themselves against LiteLLM.
The Stack
Generative UI for Agents: The Repos That Let an LLM Render Real Components
The field for making an agent 'speak UI' has split into two camps — your codebase owns the components, or the protocol does. Which repo you reach for is really a bet on who controls the widget.
The Stack
Deep Agents on Pydantic AI: The Repos for a Self-Hosted, Model-Agnostic Claude Code
Claude Code proved the 'deep agent' pattern — planning, a filesystem, sub-agents, skills. A small cluster of Python repos now rebuilds that harness on Pydantic AI, so it runs on any model you own.
The Stack
LangMem vs Mem0: Memory You Program vs Memory You Call
They get compared like rivals, but one is memory you program and the other is memory you call — and the benchmark leaderboard only measures one of them.
The Stack
Qdrant vs Milvus vs Weaviate: Filtered Search Is the Question That Separates Them
They all scale now, and they all do hybrid search. The axis that still forks the decision is the one nobody puts on a benchmark chart: how each keeps a metadata filter from wrecking recall.
The Stack
Cross-Cluster LLM Serving: Why KServe, llm-d, and Dynamo Stop at the Cluster Line
The Kubernetes-native serving stack got very good at spreading a model across a cluster. But in 2026 your GPUs aren't in one cluster — they're scattered across clouds by price and availability, and that's a different problem.
The Stack
Open-Source Deep Research Agents: 7 Repos to Build (or Run) Your Own
OpenAI and Google ship deep-research as a closed feature. These seven open repositories let you run the same plan-search-read-synthesize loop on your own models, your own sources, and — if you want — entirely on your own machine.
The Stack
Kafka vs NATS vs Redis Streams: Choosing the Event Backbone for AI Agent Systems
All three move messages between agents. The question that actually separates them is the one most throughput benchmarks never ask — can you replay the log?
The Stack
LangChain vs LangGraph vs Deep Agents: Pick a Rung, Not a Framework
Deep Agents isn't a fourth framework competing with LangChain and LangGraph — it's a preset of LangChain middleware on the same runtime. The choice is how much opinion you want pre-assembled.
The Stack
How to Chunk Code for RAG: AST-Aware Splitting vs Fixed-Size
Prose chunkers shred code mid-function and wreck the structure retrieval depends on. Here is how to split on the AST instead — and why context enrichment matters more than chunk size.
The Stack
Semantic Caching for LLM Apps: GPTCache vs Redis vs Gateway Caching
The cheapest LLM call is the one you never make. Three ways to skip it when a question is close enough to one you already answered — and the one knob that decides whether that's a feature or a bug.
The Stack
Cline vs Roo Code vs Kilo Code: Picking a VS Code Agent in 2026
Three open-source coding agents from one family tree — and the middle child just shut itself down. Its death is the most useful thing in the comparison.
The Stack
garak vs PyRIT vs promptfoo: Which LLM Red-Teaming Tool to Actually Use
Three open-source tools dominate LLM red teaming — but they aren't rivals. One scans a model, one is a framework for building attacks, one is a CI gate. Pick by layer.
The Stack
Streamlit vs Gradio vs Chainlit: Picking a Python UI for Your LLM App
They look like three flavors of the same thing. They're not — each is built around a different execution model, and that hidden choice is what makes streaming chat trivial in one and a fight in the others.
The Stack
Semantic Kernel vs AutoGen vs Microsoft Agent Framework: Which One to Build On
Microsoft just deprecated its two most-starred agent frameworks to ship a third. If you're choosing today, the decision is already made for you — here's why, and where it still loses.
The Stack
Prompt Management: Langfuse vs PromptLayer vs Agenta (and Why a Registry Isn't Enough)
A prompt registry lets you change prompts without a deploy. On its own, that just lets you change them faster — not better. The tools that compound tie every version to an eval.
The Stack
Neo4j vs FalkorDB vs Memgraph: Choosing a Graph Database for GraphRAG
The benchmark wars miss the two axes that actually decide a GraphRAG backend — where your graph lives in the memory hierarchy, and which restrictive license it ships under. The permissive option just died.
The Stack
LangChain vs LangGraph: You're Choosing a Layer, Not a Side
Since the 1.0 release, LangChain's agent helper runs on LangGraph's engine — so the real question isn't which to pick, but which layer of the same stack to write against.
The Stack
LanceDB vs sqlite-vec vs DuckDB: Embedded Vector Search for AI Agents in 2026
The embedded tier runs vector search inside your app with no server to babysit; the real choice is not speed but what your data does when it changes.
The Stack
Haystack vs LangChain vs LlamaIndex: Picking a RAG Framework in 2026
All three converged on the same runtime shape, so the old 'which can build an agent' question is dead. What's left is a bet on which layer each treats as first-class — and one differentiator nobody can copy.
The Stack
Groq vs Cerebras vs SambaNova: The Race for Faster-Than-GPU Inference
Three startups built custom silicon to outrun the GPU on token generation. The speed is real, the SRAM is tiny, and that tradeoff decides everything.
The Stack
GPT Researcher vs Open Deep Research: The Open-Source Deep Research Agents
Three open-source answers to Deep Research, and they disagree on one thing — how the research loop is controlled. One project's benchmark proves that choice is the whole game.
The Stack
AWS Bedrock vs Vertex AI vs Azure AI Foundry: Choosing an Enterprise LLM Platform
Three clouds rent you the same frontier models. The thing that actually locks you in is the agent runtime wrapped around them, and most teams pick it by accident.
The Stack
Agno vs LangGraph vs CrewAI: Choosing an Agent Framework in 2026
All three build Python agents, but they disagree on one thing — who owns the loop. That contract, not the benchmark, is what you live with for years.
The Stack
Turbopuffer vs Pinecone vs Vectorize: Serverless Vector Search in 2026
The vector database fight stopped being about speed. It's now about where your index sleeps — and whether you have one hot haystack or a million cold ones.
The Stack
Serving Many Fine-Tuned Models on One GPU: LoRAX vs vLLM vs SGLang
Multi-LoRA serving turns "one GPU per model" into "one GPU per base model, amortized across hundreds of tenants." Here are the tools that do it, and the kernel trick that makes it work.
The Stack
Composio vs Arcade vs Toolhouse: Tool Integration and Auth for AI Agents
MCP standardized how an agent calls a tool. It said almost nothing about how the agent logs in as you — and that gap is the whole product these three are selling.
The Stack
The Best Open-Source RAG Platforms: RAGFlow vs R2R vs Kotaemon
The real divide in open-source RAG isn't which library to import — it's whether to build with one at all, or deploy a finished engine. Three engines, three very different bets.
The Stack
verl vs OpenRLHF vs TRL: Choosing an RL Post-Training Framework in 2026
GRPO is now a commodity all three ship. The thing that actually sorts them is who owns the distributed orchestration — and how you keep one starving inference engine fed.
The Stack
TEI vs Infinity vs vLLM: Choosing an Embedding Inference Server in 2026
Three ways to serve embeddings at scale that look like rivals but answer a different question: should embeddings be a dedicated specialist, or ride on the GPU already running your LLM?
The Stack
smolagents vs LangGraph vs CrewAI: Three Bets on How an Agent Acts
The frameworks that get the most attention disagree on something basic — what an agent's action even is. One writes code, one wires a graph, one casts a team.
The Stack
Outlines vs XGrammar vs llguidance: Constrained Decoding Without the Throughput Tax
Forcing a model to emit valid JSON is a solved problem. Doing it without slowing generation to a crawl is the one that produced three new engines — and your serving stack probably already picked one for you.
The Stack
Open WebUI vs LibreChat vs AnythingLLM: Choosing a Self-Hosted AI Chat Front-End
Three self-hosted chat UIs that look interchangeable on a feature checklist — but each one is really built for a different person, and picking the wrong one means fighting the grain forever.
The Stack
MCP Gateways: ContextForge vs agentgateway vs MetaMCP for Taming Tool Sprawl
One agent, twenty MCP servers, and a context window drowning in tool definitions. The gateway is the layer that puts a single governed door in front of all of them.
The Stack
distilabel vs Curator vs synthetic-data-kit: Generating Training Data You Can Trust
Three open tools for making synthetic fine-tuning data. The model that generates it stopped being the hard part — the part that decides whether your dataset helps or quietly poisons your model is what happens after.
The Stack
ColPali vs Byaldi vs ColiVara: Visual Document RAG Without OCR
Three repos for retrieving over PDFs as images instead of parsed text — and why the real choice between them is who owns the multi-vector storage problem, not who has the best model.
The Stack
Browserbase vs Steel vs Browserless: Remote Browser Infrastructure for AI Agents
Your agent's automation framework drives the browser. This layer decides where that browser actually runs — and whether the sites it visits let it in.
The Stack
Aider vs Cline vs OpenHands: Three Shapes of an Open-Source Coding Agent
They aren't ranked by capability. They differ on where the agent runs and who holds the steering wheel — and that decides your blast radius, not your benchmark score.
The Stack
vLLM vs TensorRT-LLM vs TGI: Choosing a Production LLM Serving Engine
Three engines, one job: turn a model into a high-throughput endpoint. The feature gaps are closing — what's left is portability, vendor lock-in, and which project is still being built.
The Stack
Rebuff vs LLM Guard vs Vigil: The State of Open-Source Prompt-Injection Detection
Three open-source tools promise to catch prompt injection before it reaches your agent. Their GitHub status pages tell you more about whether detection works than any benchmark does.
The Stack
Presidio vs GLiNER vs LLM Redaction: Stripping PII Before the Prompt Leaves Your Network
Three ways to scrub names, card numbers, and patient IDs out of a prompt before it reaches a model provider. The hard part isn't detection — it's whether you can ever put the data back.
The Stack
pgvector vs pgvectorscale vs pgai: The Postgres-Native AI Stack
They get listed as three competing ways to do vector search in Postgres. They are not competitors — they are three rungs of one ladder, and one rung just fell off.
The Stack
Document OCR for RAG: olmOCR vs Marker vs MinerU vs Mistral OCR
A new wave of vision-model OCR turns PDFs into clean Markdown. For RAG the leaderboard everyone quotes measures the wrong thing — and is published by the people who make the tools.
The Stack
Modal vs Replicate vs RunPod vs Baseten: Where to Deploy a Custom Model in 2026
Once you've fine-tuned a model, you need a GPU to serve it from. The four serverless platforms developers reach for disagree about one thing that follows you for years — the format you package the model in.
The Stack
GraphRAG vs LightRAG vs Graphiti: Picking a Knowledge-Graph RAG Tool in 2026
Three popular repos all build a knowledge graph for your LLM. They were built for three different jobs, and the one axis that decides between them is whether your corpus sits still.
The Stack
BentoML vs Ray Serve vs KServe: Choosing a Model-Serving Framework
Three ways to put a model behind an endpoint — and they increasingly run the same engine underneath, so the thing you are actually choosing is not speed.
The Stack
Unsloth vs Axolotl vs Torchtune: Choosing an LLM Fine-Tuning Framework in 2026
Three open-source fine-tuning frameworks that look like rivals but are actually three different bets on which part of training is your real bottleneck.
The Stack
Text-to-SQL for Agents: Vanna vs WrenAI vs Dataherald
The hard part of letting an agent query your database is not the model that writes the SQL. It is feeding that model your schema. Three open-source projects bet on that, and one fine-tuned model bets against it.
The Stack
OpenLLMetry vs OpenInference: OpenTelemetry for LLM Agents in 2026
Both libraries emit OpenTelemetry spans for your agent. They disagree on what to name the attributes — and that disagreement, not the instrumentation, is your real lock-in.
The Stack
OpenAI Agents SDK vs Pydantic AI vs Google ADK: The New Frameworks, Compared
The second wave of agent frameworks is leaner, typed, and vendor-backed — and underneath the branding, they're quietly converging on the same idea.
The Stack
Ollama vs LM Studio vs Jan: Running LLMs Locally in 2026
They all wrap roughly the same inference engine, so they all run the same model at roughly the same speed. The thing that actually separates them is what shape they want to be — a daemon, a polished app, or an open one.
The Stack
Mem0 vs Zep vs Letta: Choosing a Memory Layer for Your AI Agent
Three popular open-source memory frameworks that look like rivals but are actually three different bets on where memory lives — and how much of your architecture you hand over.
The Stack
Mastra vs Vercel AI SDK vs LangGraph.js: TypeScript Agent Frameworks in 2026
The three names a JavaScript team keeps hitting when it tries to build an agent aren't competing for the same job. Two of them stack on top of the third.
The Stack
LiveKit vs Pipecat vs Vapi: Building Voice AI Agents in 2026
Every "voice agent framework" comparison pretends these three are the same tool. They sit at three different layers of the stack, and picking by features instead of layer is how teams end up rewriting.
The Stack
Instructor vs Outlines vs BAML: Getting Structured Output From an LLM
Three libraries promise the same thing — reliable JSON from a language model — and disagree completely on where to enforce it. The right pick follows one question: do you control the decoder?
The Stack
How to Build an MCP Server: A Practical Guide for Agent Developers
The protocol everyone adopted in 2025 is simpler to build for than the hype suggests — but the part that decides whether your server works isn't the code.
The Stack
Guardrails AI vs NeMo Guardrails vs Llama Guard: What Each Actually Guards
They get filed together as "LLM guardrails," but they guard three different things — format, flow, and content. Picking by stars gets you a tool that protects the wrong layer.
The Stack
GGUF vs GPTQ vs AWQ: Choosing an LLM Quantization Format in 2026
The format you pick is downstream of where you run the model — and in 2025 the tooling quietly consolidated under your feet. A field guide to the three that matter and the libraries that survived.
The Stack
FastMCP vs the Official SDK: Building an MCP Server in 2026
There are two things called FastMCP, and one of them lives inside the official SDK. Picking the right way to build an MCP server starts with untangling that — and deciding how much you want the framework to do for you.
The Stack
E2B vs Modal vs Daytona: Picking a Code Execution Sandbox for AI Agents
Three "agent sandboxes," three different machines underneath. Choose by your latency-and-lifetime profile and your isolation primitive, not by the feature grid.
The Stack
DeepEval vs Ragas vs Promptfoo: Choosing an LLM Eval Framework
Three popular eval frameworks that look interchangeable answer three different questions — pick the one that matches the question you actually have.
The Stack
CopilotKit vs assistant-ui vs Vercel AI SDK: Picking an Agent Chat UI in 2026
They all surface when you Google "AI chat UI for agents," but they own three different layers — and the ones worth shipping often stack rather than swap.
The Stack
Claude Agent SDK vs LangGraph: Inherit a Loop or Own the Graph
One hands you Anthropic's production agent loop already wired up; the other hands you a blank graph and a state machine. The choice is less "which framework" than "how much of the loop do you want to own."
The Stack
Browser Use vs Stagehand vs Playwright MCP: Browser Automation for AI Agents
Three projects give an agent a browser, but they disagree on what a page even is — pixels, DOM, or accessibility tree — and that one choice sets your token bill.
The Stack
The Best Reranker for RAG in 2026: Cohere vs Jina vs BGE
A reranker is the cheapest large win left in a RAG pipeline — a stateless model you bolt on after retrieval. The trap is choosing one by leaderboard rank instead of the two things that actually decide it.
The Stack
Temporal vs Inngest vs Restate: Durable Execution for AI Agents in 2026
Every agent that runs longer than a single request eventually crashes mid-thought. The engine you pick to survive that crash decides how you're allowed to write the loop.
The Stack
RouteLLM vs NotDiamond vs Martian: Do LLM Model Routers Actually Cut Costs?
Per-prompt model routing promises GPT-quality answers at a fraction of the bill. The honest 2026 answer is that it's a cost lever with a threshold, not a free one — and a neutral benchmark disagrees with the marketing.
The Stack
n8n vs Flowise vs Langflow: Choosing a Visual Agent Builder in 2026
All three give you a drag-and-drop canvas for building AI agents. The choice that actually matters is hidden underneath: what each one thinks it's automating, and whether its license lets you ship it.
The Stack
LiteLLM vs Portkey vs TensorZero: Choosing an LLM Gateway in 2026
Every agent ends up talking to more than one model provider. The library you put in the middle decides whether that seam stays a proxy or quietly becomes your control plane.
The Stack
GraphRAG vs Vector RAG: When a Knowledge Graph Actually Earns Its Cost
Microsoft GraphRAG, LightRAG, and LazyGraphRAG all promise smarter retrieval. The honest question isn't which to pick — it's whether your queries are the kind a graph can even help.
The Stack
Firecrawl vs Crawl4AI vs Jina Reader: Feeding the Web to an AI Agent
All three turn a webpage into clean markdown an LLM can read. They are not competing on that — they sit on three different rungs, and picking by star count gets the rung wrong.
The Stack
DSPy vs TextGrad vs AdalFlow: Optimizing Prompts Instead of Writing Them
Three Python libraries that treat your prompt as a parameter to be tuned, not a string to be hand-crafted. They disagree about what the optimizer needs from you — and that's the whole decision.
The Stack
Docling vs Unstructured vs LlamaParse: Parsing Documents for RAG in 2026
The fight you think you're having — open pipeline vs hosted LLM parser — ended last year. A 1.2B model on your own GPU now wins the part that actually matters.
The Stack
Deepgram vs AssemblyAI vs Whisper: Speech-to-Text for Voice Agents in 2026
Whisper tops the accuracy leaderboard and loses the conversation. For a live voice agent, the number that decides whether the bot feels human isn't word error rate — it's who detects the end of your turn.
The Stack
Chroma vs Weaviate vs Milvus: Picking an Open-Source Vector Database in 2026
The old way to choose was "which one scales." That axis has quietly collapsed — all three now run on a laptop and across a cluster. What's left is a question about default posture and the ops bill you're signing up for.
The Stack
Your Container Is Not A Sandbox
Agents that write their own code forced an old infrastructure question back into the open — where, exactly, does the security boundary live, and what does it cost to drop it a layer lower?
The Stack
Three Places to Keep an Agent's Memory
The memory libraries aren't competing on accuracy. They're competing on geography — where the remembering happens relative to your agent's loop. Pick the place, not the benchmark.
The Stack
The Trace Is the New Log
Agent observability didn't invent a standard. It surrendered to a boring one from 2019 — and in doing so quietly retired the log as the unit of truth.
The Stack
The Evals Are the Product
Agents got trivial to build and impossible to trust. The repos worth starring now aren't frameworks — they're the eval and tracing layer that tells you whether the thing actually works.
The Stack
The Agent That Cannot Wait Its Turn
Every framework on this site assumes a turn: request, then response. Voice agents break that contract — the model has to listen and speak at once — and the repos handling it are quietly a different species.
The Stack
The Agent Forgets, the Workflow Remembers
You can't argue an 85%-reliable model into being 99% reliable. But you can wrap it so that every failed step re-runs from its last good checkpoint without redoing the damage. That layer has a name.
The Stack
Memory Stopped Being a Layer
The hard problem of agent memory was never remembering. It's knowing when a remembered fact has quietly stopped being true.
The Stack
LlamaIndex vs LangChain: Which Framework in 2026, and When Neither Is the Answer
They started on opposite ends — one indexed your documents, one chained your calls. In 2026 they've converged. The real choice is which abstraction you want to debug at 3am.
The Stack
LangGraph vs CrewAI vs AutoGen: How to Choose an Agent Framework in 2026
All three claim to build multi-agent systems. The real question isn't features — it's who owns the control flow, and the answer changes which one is the right call.
The Stack
Langfuse vs LangSmith vs Arize Phoenix: Choosing LLM & Agent Observability in 2026
The real choice isn't which dashboard looks nicer — it's what unit of work you trace and who owns the trace data after the agent finishes.
The Stack
From Framework to Harness
The agent libraries that mattered in 2024 told the model what to do next. The ones that matter now assume it already knows — and sell you the restraints and the trace instead.
The Stack
Two Ways to Show an Agent a Web Page
The fight in browser automation isn't whether an agent can click. It's whether it reads the page's accessibility tree or its pixels — and which failure you'd rather debug at 3 a.m.
🎧 Listen
The Stack
Agent Memory and State
Nine repositories tackling the hardest unsolved problem in agent design — remembering, retrieving, and forgetting across the lifetime of a conversation.
🎧 Listen
The Stack
The MCP Ecosystem Worth Installing
A field guide to the Model Context Protocol repositories that actually matter — the SDKs, the reference servers, and the connectors that earn a place in your config.
🎧 Listen
The Stack
Repositories Every AI Agent Should Star
The dozen codebases that quietly define what it means to be an agent in 2026 — frameworks, orchestration layers, and the tools that turn intent into action.