All 71 tools

Why you'd want it

Claude Code runs in the terminal, VS Code, JetBrains IDEs, a desktop app and the browser, and every surface shares the same CLAUDE.md files, settings and MCP servers. It plans multi-file changes, runs tests, stages commits and opens pull requests, and it can read an existing AGENTS.md. Subagents, skills, hooks and a non-interactive claude -p mode let you script it in CI, and the Agent SDK exposes the same tools for building your own agents.

Best for

• Developers who want one agent across terminal and IDE
• Teams automating PR review and issue triage in CI
• Builders working with Claude models

Use it when

You want an agent that works across a whole repo, runs your tools and handles git, and you have a Claude subscription or Anthropic Console account.

Why you'd want it

Codex CLI works against your local repository with the tools already installed on your machine, and you choose the model, reasoning effort, permissions and sandbox for each run. You can use it interactively or call codex exec from scripts and CI, run a review against uncommitted changes, a commit or a base branch, add MCP servers with codex mcp, and hand work off to Codex cloud. You sign in with a ChatGPT plan or use an API key.

Best for

• ChatGPT Plus, Pro, Business, Edu or Enterprise users
• Scripted runs in CI with codex exec
• Reviewing changes before a commit

Use it when

You want a terminal coding agent on OpenAI models with control over sandboxing and approvals, and you have a ChatGPT plan or OpenAI API key.

Why you'd want it

Context7 targets outdated training data and hallucinated APIs by fetching documentation and code examples for the library and version you name in the prompt. Its MCP server has two tools: resolve-library-id maps a library name to a Context7 ID, and query-docs returns docs relevant to a question. It can also run without MCP as the ctx7 CLI plus an agent skill, and npx ctx7 setup configures either mode for Cursor, Claude Code or OpenCode.

Best for

• Coding agents working with fast-moving libraries
• Pinning answers to a specific library version
• Cursor and Claude Code users

Use it when

Your agent keeps writing code against outdated or nonexistent APIs for the libraries you depend on.

Why you'd want it

Langfuse instruments an app through Python and JS/TS SDKs or integrations such as the OpenAI SDK, LangChain, LlamaIndex, Vercel AI SDK and Mastra, and records LLM calls, retrieval and agent actions as traces you can inspect. The same platform covers prompt management with server and client caching, datasets for pre-deployment tests, and evaluations via LLM-as-a-judge, code evaluators, user feedback and manual labeling. You can use Langfuse Cloud or self-host it with Docker Compose, on a VM or on Kubernetes via Helm.

Best for

• Teams that want to self-host LLM observability
• Tracing, prompts and evals in one place
• Python and JS/TS stacks

Use it when

You need to see what your LLM app or agent did on each request and want to evaluate and iterate on prompts against the same traces.

Why you'd want it

LangGraph is a low-level orchestration layer for agents and workflows that need to persist through failures and resume exactly where they left off. It provides short-term working memory and long-term memory across sessions, and lets a human inspect and modify agent state at any point during execution. It is built by LangChain Inc. but can be used without LangChain, and an equivalent JS/TS library, LangGraph.js, is available.

Best for

• Long-running stateful agents
• Workflows with human review steps
• Teams already using LangChain or LangSmith

Use it when

You want explicit control over an agent's control flow and state, with checkpoints it can resume from after a failure or a human review.

Why you'd want it

MCP is the protocol behind every server in this category: a server exposes tools, resources and prompts once, and any MCP client, such as Claude, ChatGPT, VS Code or Cursor, can discover and call them. Messages are JSON-RPC 2.0 over stdio for local servers or Streamable HTTP for remote ones, with OAuth recommended for remote auth. Official SDKs cover TypeScript, Python, C#, Go, Rust, Ruby, Java, Swift, PHP and Kotlin, so you can build a server or client in the language you already use.

Best for

• Exposing your own API or data to AI clients
• Building an agent host that connects to many servers
• Standardizing tool integrations across clients

Use it when

You want agents to reach an internal system or service, or you are building a client that should plug into existing MCP servers.

Why you'd want it

Microsoft's MCP server exposes Playwright browser automation as tools that act on structured accessibility snapshots, so no vision model is needed and actions avoid the ambiguity of screenshot-based clicking. It runs Chrome, Firefox, WebKit or Edge, headed or headless, can attach to your logged-in browser through the Playwright extension, and has opt-in capabilities for network, storage, DevTools, PDF, vision and test assertions. The README positions MCP for long-running loops that need persistent browser state, and points coding agents to the more token-efficient Playwright CLI with skills.

Best for

• Exploratory web automation by agents
• Self-healing tests and long-running browser workflows
• MCP clients without built-in browser control

Use it when

Your agent needs to navigate, fill forms and inspect pages across many steps while keeping the same browser session.

Why you'd want it

OpenCode has two built-in agents you switch between with Tab: build, with full access for development work, and plan, which is read-only, denies file edits by default and asks before running bash commands. It supports many LLM providers out of the box, connected from the TUI with /connect, and extends through MCP servers, plugins, agent skills and custom commands. The team also sells OpenCode Go, a subscription for open-source models, but you can use your own provider keys instead.

Best for

• Terminal users who want provider choice
• Separating read-only planning from editing
• Using the same agent from a TUI, desktop app or web UI

Use it when

You want an MIT-licensed coding agent that works with many model providers and offers a TUI, a desktop app and a local web interface.

Why you'd want it

LangChain is a framework for building agents and LLM apps from interoperable components, with a large library of integrations for model providers, tools, vector stores and retrievers. Its standard model interface lets you swap models as you experiment without rebuilding the app. An equivalent JS/TS library, LangChain.js, is available, and it pairs with LangGraph for lower-level orchestration and LangSmith for evals and tracing.

Best for

• Apps that need many model or data integrations
• Switching between model providers
• Prototyping LLM apps in Python or JS

Use it when

You want ready-made integrations for models, vector stores and retrievers, and a single interface for switching providers.

Why you'd want it

Ollama downloads and runs open models such as Gemma with one command (ollama run gemma4) and serves them on a local REST API at localhost:11434. It supports a subset of the OpenAI API, so OpenAI clients work by changing the base URL, and it ships official Python and JavaScript libraries. ollama launch connects local models to coding agents including Claude Code, Codex, Copilot CLI and OpenCode, and the same API can reach Ollama's cloud models with an API key.

Best for

• Running open models on your own machine
• Offline or private agent development
• Pointing coding agents at local models

Use it when

You want a local model server that existing OpenAI-style clients and coding agents can talk to with minimal setup.

Why you'd want it

The OpenHands repo now ships Agent Canvas, a self-hosted UI that runs the open-source OpenHands agent and can also drive Claude Code, Codex, Gemini CLI, OpenCode or any ACP-compatible agent. Agents run on Agent Server backends on your laptop, in Docker containers, on VMs or in OpenHands Cloud, and you switch between backends from one frontend. Automations run on a schedule or on webhook events and connect to Slack, GitHub, Linear and Notion.

Best for

• Teams running always-on agents on their own servers
• Running several agents in isolated Docker containers
• Scheduled and webhook-driven agent automations

Use it when

You want coding agents on a server or in Docker sandboxes so they keep working when your laptop is closed, and you want to trigger them from Slack or GitHub.

Why you'd want it

The specify CLI installs skills or command files for your coding agent, which you then run in chat: constitution once per project, then specify, plan, tasks, implement and converge for each feature. Optional extensions add a bug-fixing flow (assess, fix, test) and an idea assessment flow that ends in a go, clarify or stop decision, with reports saved as Markdown under .specify/. It has integrations for dozens of agents, including GitHub Copilot, Claude Code, Codex CLI, Cursor, Gemini CLI and Zed, and you can customize it with extensions, presets and workflows.

Best for

• Teams that want a spec before code
• Keeping agent work reviewable step by step
• Using one process across several coding agents

Use it when

You want a coding agent to work from a written specification, plan and task list rather than one prompt, with artifacts you review at each step.

Why you'd want it

Cline edits files across a project, runs terminal commands and reacts to their output, and in VS Code and JetBrains each edit appears as a diff with checkpoints so you can undo its work. Plan mode explores the codebase and proposes a strategy before Act mode carries it out, and every edit and command needs your approval unless you turn on auto-approve. It works with Anthropic, OpenAI, Gemini, OpenRouter, Bedrock, Ollama, LM Studio and any OpenAI-compatible API, and extends through MCP servers, SDK plugins and .clinerules files.

Best for

• VS Code and JetBrains users
• Developers who want to approve each action
• Bring-your-own-model or local-model setups

Use it when

You want an agent inside your editor that asks before each change, and you want to pick the model provider yourself.

Why you'd want it

LiteLLM gives one interface to OpenAI, Anthropic, Gemini, Bedrock, Azure and many other providers using the OpenAI request format, so you can swap providers without rewriting code. The Python SDK includes a Router with retry and fallback logic across deployments. The proxy server adds virtual keys, per-project spend tracking, guardrails, load balancing and an admin dashboard, and it can also act as an MCP gateway and an A2A agent gateway.

Best for

• Platform teams centralizing LLM access
• Multi-provider apps with fallbacks
• Tracking spend per project or key

Use it when

You call several model providers and want one OpenAI-format API, or a central gateway with keys, budgets and logging for a team.

Why you'd want it

Mem0 extracts facts from conversations with an LLM call and stores them so later turns can search them by user, session or agent. Retrieval combines semantic search, BM25 keyword matching and entity linking, with time-aware ranking for questions about current state versus past events. You can run it as a library from pip or npm, as a self-hosted server with a dashboard and API keys through Docker Compose, or on the managed Mem0 Platform.

Best for

• Personalized assistants and support bots
• Remembering user preferences across sessions
• Starting with a library and moving to a managed service later

Use it when

Your agent should remember facts about users or its own past actions between conversations without you designing the storage and retrieval.

Why you'd want it

Skills are folders with a SKILL.md file of instructions and metadata, plus optional scripts and resources, that Claude loads dynamically for specialized tasks. This repo collects Anthropic's examples across creative, technical and enterprise work (for example mcp-builder, webapp-testing, skill-creator and frontend-design), the docx, pdf, pptx and xlsx skills that power Claude's document features, a skill template and the Agent Skills specification. In Claude Code you can add the repo as a plugin marketplace and install document-skills or example-skills.

Best for

• Learning how to write a skill
• Adding document skills to Claude Code
• Starting a new skill from a template

Use it when

You are writing your own skills and want working patterns to copy, or you want Anthropic's document and example skills in Claude Code.

Why you'd want it

It gives an agent the parts of Chrome DevTools a developer reaches for: recording performance traces with extracted insights, inspecting network requests, reading console messages with source-mapped stack traces and taking screenshots. Automation runs on Puppeteer and waits for action results automatically. A --slim mode trims the tool set for basic browser tasks, and a separate CLI works without MCP.

Best for

• Debugging front-end bugs with an agent
• Performance analysis of web pages
• Checking console and network errors after a code change

Use it when

You want your coding agent to check its changes in a real Chrome instance, reading console, network and performance data the way you would in DevTools.

Why you'd want it

Browser Use is an open-source browser agent: you give it a task in plain language and a model, and it opens a browser, works through the site and returns a result. It works with OpenAI, Anthropic and Google models or local models through Ollama, accepts custom tools registered as Python functions, and can drive a local Chrome profile, a remote browser over CDP or a Browser Use Cloud browser. A CLI gives existing agents such as Claude Code, Codex and Cursor browser access, and an integration implements Claude's browser toolset with Browser Use as the driver.

Best for

• Python apps that automate tasks on real websites
• Giving a coding agent browser access
• Projects that may move to hosted browsers later

Use it when

You want an agent that completes tasks on live websites, such as forms, bookings and lookups, from your own Python code with your choice of model.

Why you'd want it

You declare a tool as a Python function and FastMCP generates the schema, validation and documentation; when you connect to a server by URL, it handles transport negotiation, authentication and the protocol lifecycle. Besides servers and clients it supports apps, which give tools interactive UIs rendered in the conversation. FastMCP 1.0 was incorporated into the official MCP Python SDK in 2024, and Prefect maintains a TypeScript counterpart.

Best for

• Python developers writing MCP servers
• Calling MCP servers from Python code
• Tools that need an interactive UI in chat

Use it when

You are writing an MCP server or client in Python and want schemas, transports and auth handled for you.

Why you'd want it

GitHub's official MCP server lets an agent browse and search code, manage issues and pull requests, monitor Actions runs and review code scanning and Dependabot alerts. GitHub hosts a remote version at api.githubcopilot.com/mcp with OAuth or personal access token auth, and the same server runs locally from a Docker image or a Go binary. Tools are grouped into toolsets you can enable selectively, and a read-only mode removes every tool that makes changes.

Best for

• Agents that triage issues or review pull requests
• Investigating CI failures from the editor
• Teams that want a hosted server with OAuth

Use it when

Your agent needs to read or act on GitHub repositories, issues, pull requests or workflows as part of its task.

Why you'd want it

Mastra is a TypeScript framework for agents and workflows that plugs into React, Next.js and Node apps or runs as a standalone server. It connects to 40+ model providers through one interface, has a graph-based workflow engine with .then(), .branch() and .parallel(), and can suspend an agent or workflow for human input and resume from stored state. It also covers conversation history, RAG, observational memory, MCP server authoring, evals and observability.

Best for

• TypeScript and Next.js teams
• Agents with human approval steps
• Apps that need memory and RAG in one stack

Use it when

You want agents, workflows, memory and evals in one TypeScript framework instead of assembling separate libraries.

Why you'd want it

The OpenAI Agents SDK is a lightweight Python framework where agents are LLMs configured with instructions, tools, guardrails and handoffs to other agents. It is provider-agnostic, supporting the OpenAI Responses and Chat Completions APIs plus 100+ other LLMs, and includes sessions for conversation history, human-in-the-loop, and built-in tracing of agent runs. It also covers sandbox agents that work in a container over long tasks, plus realtime and voice agents.

Best for

• Multi-agent apps with handoffs
• Voice and realtime agents
• Teams on the OpenAI API

Use it when

You want a small set of primitives (agents, tools, handoffs, guardrails) with tracing built in, and may want voice or sandboxed agents later.

Why you'd want it

The AI SDK is a provider-agnostic TypeScript toolkit with a unified API across providers such as OpenAI, Anthropic and Google. generateText covers text and Zod-typed structured output, ToolLoopAgent runs tool-calling agents, and AI SDK UI provides framework-agnostic hooks for chat and generative UIs in Next.js, React, Svelte and Vue. By default it routes model strings through the Vercel AI Gateway, and you can install provider packages to connect to providers directly.

Best for

• Next.js and React apps
• Streaming chat UIs
• Switching model providers in TypeScript

Use it when

You are building an AI feature or agent into a web app and want the model calls and the chat UI from one library.

Why you'd want it

Promptfoo is a CLI and library that runs automated evaluations of prompts and models, compares providers such as OpenAI, Anthropic, Azure, Bedrock and Ollama side by side, and shows results in a web viewer. It also does red teaming and vulnerability scanning, and can review pull requests for LLM-related security and compliance issues. Evals run locally, it works with any LLM API or programming language, and it plugs into CI/CD.

Best for

• Regression tests for prompts in CI
• Comparing models side by side
• Red teaming LLM apps before launch

Use it when

You want repeatable, local eval runs and security scans that can gate changes in CI.

Why you'd want it

Pydantic AI gives you an agent whose tools and outputs are typed: tool arguments are validated before your code runs, and a run is guaranteed to return the output type you declared. The same agent can run behind a web frontend, in the terminal, on a voice call, or under durable execution with Temporal, DBOS or Prefect. Pydantic AI Harness adds capabilities such as memory, guardrails, sub-agents, planning and context management, and its instrumentation is plain OpenTelemetry.

Best for

• Typed data extraction
• Python teams already using Pydantic
• Durable background agents on Temporal or DBOS

Use it when

You want type checking and validation across tools and outputs, plus the option to switch model providers without rewriting the agent.

Why you'd want it

Phoenix collects traces through OpenTelemetry-based OpenInference instrumentation, with integrations for frameworks such as the OpenAI Agents SDK, Claude Agent SDK, LangGraph and Vercel AI SDK across Python, JavaScript, Java and Go. On top of traces it offers LLM-based evals, versioned datasets, experiments, a prompt playground and prompt management. It runs locally with phoenix serve, in a container or on Kubernetes, and exposes a remote MCP endpoint so Claude Code, Cursor and other MCP clients can query traces, datasets and experiments.

Best for

• Local trace debugging during development
• OpenTelemetry-based stacks
• Self-hosted eval and experiment tracking

Use it when

You want an observability and eval UI on your own machine or infrastructure, instrumented with OpenTelemetry rather than a vendor-specific SDK.

Why you'd want it

E2B gives agent tasks their own isolated sandbox in the cloud, started with Sandbox.create() from the JavaScript or Python SDK, where code can run shell commands and programs. The Code Interpreter SDK adds runCode/run_code for executing snippets, and the Desktop SDK adds mouse, keyboard, screenshot and desktop streaming APIs for computer-use agents. The runtime is open source and can be self-hosted with Terraform on AWS, Google Cloud, Azure or a general Linux machine.

Best for

• Running untrusted model-generated code
• Code interpreter and data analysis features
• Computer-use agents that need a desktop

Use it when

Your agent writes code or shell commands that must run somewhere isolated from your own machines and data.

Why you'd want it

The Agent SDK is a library that runs the Claude Code binary, so your agent gets the same tools (read, write and edit files, run commands, search the web), agent loop and context management that power Claude Code. You can add custom tools as in-process MCP servers, run hooks at points in the agent lifecycle, spawn subagents, control which tools run automatically through permissions, and resume or fork sessions. It is available for Python (claude-agent-sdk) and TypeScript (@anthropic-ai/claude-agent-sdk).

Best for

• Agents that edit files and run commands
• Teams already using Claude Code
• Embedding a coding agent in your own app

Use it when

You want Claude Code's tool set and permission model inside a process you operate, instead of writing the tool loop yourself.

Why you'd want it

The Inspector is the reference developer tool from the MCP project for testing and debugging servers. One npx package gives you a web client that shows the JSON-RPC exchange as you call tools, a CLI with JSON output for CI, shell pipelines and coding agents, and a terminal UI; all three share the same transports, config files and OAuth state. It also installs mcpdo, an experimental client that keeps one connection open across many commands.

Best for

• MCP server authors
• Smoke-testing MCP servers in CI
• Letting a coding agent check its own MCP server from the shell

Use it when

You are building or debugging an MCP server and want to list and call its tools directly, interactively or from a script.

Why you'd want it

The server exposes Firecrawl scrape, map, crawl, search, parse, interact and agent tools, plus monitors for recurring page checks and a credit usage tool. A hosted endpoint works keyless for scrape, search and parse within rate limits, and signing in or adding an API key unlocks the full tool set. You can also run it locally with npx or Docker and point it at a self-hosted Firecrawl API with FIRECRAWL_API_URL.

Best for

• Turning URLs into clean markdown or schema-shaped JSON
• Crawling many pages under one site
• Pages that need a click before they can be read

Use it when

Your agent needs content from known URLs, a whole site or a search query, in a format it can read directly.

Why you'd want it

The Claude API at api.anthropic.com covers the Messages API, Message Batches (asynchronous, at a 50% cost reduction), token counting, a Files API and a Skills API, with beta Agents, Sessions and Environments APIs for running managed agents in cloud sandboxes. The official SDKs handle auth headers, retries, streaming and typed requests, and the Python SDK adds tool helpers and a tool runner. Claude is also available through Amazon Bedrock, Google Cloud, Claude Platform on AWS and Microsoft Foundry if you need cloud billing and IAM.

Best for

• Building agents on Claude models
• Direct access to the latest Claude features
• Large asynchronous batch jobs

Use it when

You are building on Claude and want direct access to the latest models and features with Anthropic billing and support.

Why you'd want it

Supabase hosts the server at mcp.supabase.com, so most clients need only the URL and an OAuth login to reach your projects. Tools are grouped into features (database, debugging, development, Edge Functions, account, docs, branching, storage) that you can restrict, and you can scope the server to one project or run it in read-only mode, where SQL runs as a read-only Postgres user. The npm package also exports tool schemas for the Vercel AI SDK MCP client and a handler for serving the tools from your own endpoint.

Best for

• Apps built on Supabase
• Letting a coding agent inspect schemas and apply migrations
• Debugging with project logs and advisors

Use it when

Your app runs on Supabase and you want the agent to read schemas, run SQL, apply migrations or check logs from your editor.

Why you'd want it

llama.cpp is a dependency-free C/C++ inference engine that runs on a wide range of hardware: Metal on Apple silicon, CUDA, HIP, Vulkan, SYCL, WebGPU and CPU builds, with CPU+GPU hybrid inference for models larger than your VRAM. It supports 1.5-bit to 8-bit quantization to cut memory use. llama cli -hf <repo> downloads and runs a model straight from Hugging Face, and llama serve starts an OpenAI-compatible API server with a built-in web UI that agents and editors can call.

Best for

• Local inference on laptops and mixed hardware
• Quantized models on limited memory
• Self-hosted OpenAI-compatible endpoints

Use it when

You want direct control over local inference, quantization and hardware backends, or a lightweight OpenAI-compatible server.

Why you'd want it

Gemini CLI is a terminal agent with built-in file, shell, web fetch and Google Search grounding tools, and it adds MCP servers configured in ~/.gemini/settings.json. It reads project context from GEMINI.md, can checkpoint and resume sessions, and has a headless mode with JSON and streaming JSON output for scripts. A separate GitHub Action uses it for PR reviews and issue triage.

Best for

• Teams with a Gemini Code Assist Standard or Enterprise license
• Google Cloud and Vertex AI users
• Scripted runs that need JSON output

Use it when

Your organization has a Gemini Code Assist Standard or Enterprise license, or you pay for Gemini API or Vertex AI access, and you want a terminal agent on Gemini models.

Why you'd want it

vLLM is an inference and serving engine built around PagedAttention, continuous batching, chunked prefill and prefix caching, with many quantization formats and speculative decoding. It runs an OpenAI-compatible API server plus Anthropic Messages API and gRPC support, with tool calling and reasoning parsers and structured outputs via xgrammar or guidance. Tensor, pipeline, data and expert parallelism cover distributed inference, and it supports 200+ Hugging Face model architectures on NVIDIA, AMD and Intel GPUs, CPUs and hardware plugins.

Best for

• Self-hosting open models on GPUs
• Serving many concurrent agent requests
• Distributed multi-GPU inference

Use it when

You need to serve open-weight models to agents or apps at scale on your own GPU infrastructure.

Why you'd want it

CrewAI is a standalone Python framework with its own primitives for agents, tasks, crews, flows, tools and orchestration. Crews let role-based agents collaborate and delegate tasks autonomously, while Flows give event-driven control with state management and conditional branching, and the two can be combined. The crewai CLI scaffolds a project where agents and tasks are defined in JSONC files and run with crewai run.

Best for

• Multi-agent teams with defined roles
• Business process automation
• Mixing autonomous agents with deterministic steps

Use it when

You want several specialized agents with clear roles and tasks, wrapped in deterministic, event-driven workflows in regular Python.

Why you'd want it

The reference fetch server from the MCP project. Its single fetch tool converts HTML to markdown, truncates long pages and takes a start_index so the model can continue reading where it stopped, with a raw option for unconverted content. By default it obeys robots.txt for model-initiated requests and refuses private, loopback and cloud metadata addresses; flags let you set the user agent, use a proxy or allow private IPs.

Best for

• Adding web page reading to a client that lacks it
• Reading docs and articles as markdown
• Python or uv-based setups

Use it when

Your agent needs to read web pages by URL and your client has no built-in web fetch tool.

Why you'd want it

The reference filesystem server from the MCP project, published on npm as @modelcontextprotocol/server-filesystem. Access is limited to allowed directories passed on the command line or supplied by the client through MCP Roots, which can change at runtime without a restart. Every tool carries read-only, idempotent and destructive hints, so clients can tell a directory listing apart from an overwrite.

Best for

• Giving Claude Desktop or another chat client local file access
• Scoped file access for agents without built-in file tools
• Learning how an MCP server is built

Use it when

Your MCP client has no file access of its own and you want to grant it specific directories, optionally read-only through a Docker mount.

Why you'd want it

goose is a local agent for code as well as research, writing, automation and data analysis, available as a desktop app for macOS, Linux and Windows, a CLI and an API. It works with 15+ providers including Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure and Bedrock, and can use existing Claude, ChatGPT or Gemini subscriptions through ACP. It connects to 70+ extensions over MCP, and you can build custom distributions with preconfigured providers, extensions and branding.

Best for

• Agents for tasks beyond coding
• Desktop app users who also want a CLI
• Teams building an internal agent distribution

Use it when

You want an open-source local agent that is not tied to one model vendor and that you extend with MCP servers.

Why you'd want it

The LlamaIndex framework is a Python toolkit for context augmentation: data connectors ingest APIs, PDFs, docs and SQL, indexes structure the data, and query and chat engines retrieve context for the model. Agents can call a RAG pipeline as one tool among many, and Workflows add event-driven, multi-step processes with branching, retries and human-in-the-loop review. You can start with the llama-index starter package or install llama-index-core plus only the integrations you need from over 300 packages.

Best for

• RAG over private documents
• Agents that query your own data
• Pairing with LlamaParse for hard documents

Use it when

Your agent's main job is answering questions or taking actions over your own documents and data sources.

Why you'd want it

Agno is a Python SDK with three primitives (agents, teams and workflows) plus a runtime, AgentOS, that serves them through a production API with 50+ endpoints over SSE and websockets. Sessions, memory, knowledge and traces are stored in your own database, and the runtime adds human approval, OpenTelemetry tracing, JWT-based RBAC with multi-tenant isolation, cron scheduling, and interfaces for Slack, Telegram, WhatsApp, Discord, AG-UI and A2A. Starter templates deploy it with Docker to Railway, AWS, GCP, Azure, Fly, Render, Modal or Helm.

Best for

• Self-hosted agent platforms
• Serving agents to many users
• Agents exposed in Slack or messaging apps

Use it when

You want to build agents and also run them as a multi-user service on your own infrastructure, with data kept in your own database.

Why you'd want it

Cognee ingests text, code and session data and builds connected memory: entities, relationships and searchable chunks for text, and a graph of symbols and dependencies for code. Its API centers on four operations (remember, recall, improve and forget), and with the gliner extra it builds and queries memory with small local CPU models and no API key, while adding an LLM key enables generated answers. It ships plugins for Claude Code and Codex, an MCP server for other clients, a REST API and Docker images for self-hosting.

Best for

• Agent memory across runs on your own infrastructure
• Shared memory over docs, tickets and code
• Local experiments without an LLM API key

Use it when

You want agents to keep and query project knowledge, past decisions and fixes across sessions, on infrastructure you control.

Why you'd want it

DSPy replaces hand-written prompts with Python code: signatures declare typed inputs and outputs, and modules such as Predict, ChainOfThought and ReAct control how a signature runs, including tool use. You compose modules with plain Python control flow into pipelines, RAG systems or agent loops. Optimizers such as GEPA, MIPROv2 and BootstrapFewShot take examples and a scoring function and tune the program's prompts and weights, and the result can be saved and reloaded.

Best for

• Multi-step LLM pipelines
• Teams with labeled examples and a metric
• Replacing brittle prompt templates

Use it when

You want LLM behavior defined in code and improved systematically against a metric rather than by editing prompts by hand.

Why you'd want it

Graphiti turns episodes (raw text or JSON) into entities and relationships and gives each fact a validity window, so when information changes the old fact is invalidated rather than deleted and you can query what was true at any point. New data is added incrementally without recomputing the graph, and retrieval combines semantic embeddings, BM25 keyword search and graph traversal. Every fact traces back to the episode that produced it, custom entity and edge types are defined with Pydantic models, and a bundled MCP server lets assistants add and search memory.

Best for

• Agents working on data that changes over time
• Memory that needs provenance back to sources
• Teams comfortable running a graph database

Use it when

You need agent memory that answers questions about relationships and history, not just similar text chunks.

Why you'd want it

Crush lets you pick from many LLM providers, or add your own through OpenAI- or Anthropic-compatible APIs and local runtimes such as Ollama and LM Studio, and switch models mid-session without losing context. It keeps multiple sessions per project, pulls extra context from language servers, and extends through MCP servers over http, stdio and sse, plus agent skills and hooks. It runs in terminals on macOS, Linux, Windows, Android, FreeBSD, OpenBSD and NetBSD.

Best for

• Terminal users on any OS, including the BSDs
• Switching models mid-session
• LSP-aware context for the agent

Use it when

You want a terminal agent that is not tied to one model vendor and can use the language servers you already run.

Why you'd want it

ADK is a code-first framework where you define agents, tools and orchestration in Python, then compose them into multi-agent hierarchies or graph-based workflows with routing, fan-out/fan-in, loops, retries and human-in-the-loop. It ships a CLI with an interactive runner, a local web UI for testing and debugging, an adk eval command, and deploy commands for Docker and Cloud Run, with Vertex AI Agent Engine for scaling. It is optimized for Gemini but model-agnostic, and tools can come from custom functions, OpenAPI specs or MCP.

Best for

• Teams on Gemini and Google Cloud
• Multi-agent hierarchies
• Agents that need built-in evaluation

Use it when

You want agent definitions, a local testing UI, evaluation and deployment to Cloud Run in one toolkit.

Why you'd want it

Opik, built by Comet, logs nested traces through a @track decorator in Python, a TypeScript SDK or OpenTelemetry, so multi-step agent runs and tool calls show up as full trace trees. It adds datasets, experiments, LLM-as-a-judge metrics for hallucination, moderation and RAG, a PyTest integration for CI, online evaluation rules, dashboards and an Agent Optimizer SDK. The full platform, backend included, is Apache-2.0 and can be self-hosted with Docker Compose or Helm, or used on Comet's cloud.

Best for

• Teams that want a fully Apache-2.0 self-hosted platform
• Agent tracing and evals in one tool
• Running LLM evals in PyTest

Use it when

You want tracing, evaluation and production monitoring under one open source license you can self-host, or want your coding agent to read traces through Opik's MCP server.

Why you'd want it

Stagehand mixes ordinary browser code (goto, click, locator) with three AI calls: act performs an action described in plain language, observe returns real selectors, and extract returns data validated against a Zod or Pydantic schema. Because observe hands back selectors, you can fill credentials yourself without sending them to the model, and the README says act, observe and extract refresh how an action happens when a site changes. It runs against a local Chrome or a Browserbase cloud browser, which adds a model gateway, server-side caching, proxies and session recordings.

Best for

• Developers who already write Playwright-style scripts
• Structured data extraction from logged-in sites
• TypeScript, Python or Go codebases

Use it when

You want to keep control of each browser step in code but let a model handle brittle selectors and data extraction.

Why you'd want it

ccusage reads the usage data that coding agent CLIs store locally and turns it into daily, weekly, monthly and session reports, with per-model breakdowns and separate cache token counts. One report covers Claude Code, Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and more than a dozen other tools, and there are Claude Code extras such as 5-hour billing window reports and a status line integration. Output is a table or JSON, and an offline mode uses cached pricing data.

Best for

• Tracking spend across several coding agents
• Claude Code users watching 5-hour usage windows
• Exporting usage as JSON for your own dashboards

Use it when

You want to see how many tokens and dollars your coding agent sessions use, by day, model, session or project.

Why you'd want it

Paste a Figma link into your agent's chat and the server fetches that design's metadata from the Figma API, then simplifies it to the layout and styling information before handing it to the model. The author's case is that this reduced, structured context lets the model implement designs more accurately than pasting screenshots. It runs locally through npx with your own Figma access token.

Best for

• Implementing Figma designs in code
• Cursor users
• Front-end work from design handoff

Use it when

You build UI from Figma designs and want the agent to read the actual file data instead of a screenshot.

Why you'd want it

Instructor lets you pass a Pydantic model as response_model and get back a typed, validated object instead of parsing JSON or tool calls yourself. instructor.from_provider uses the same API for OpenAI, Anthropic, Google, Ollama, Groq and other providers. Failed validations are retried with the error message, partial objects can be streamed as they are generated, and nested models work without extra code. Ports exist for TypeScript, Ruby, Go and Elixir.

Best for

• Structured extraction from text
• Pydantic-based Python apps
• Typed outputs across providers

Use it when

You need reliable structured data from an LLM call and want validation and retries handled for you.

Why you'd want it

DeepEval works like Pytest for LLM apps: you write test cases and assert them against metrics such as G-Eval, task completion, tool correctness, answer relevancy, faithfulness and hallucination, then run them with deepeval test run. Metrics cover agents, RAG, multi-turn chat, MCP use and multimodal output, can be powered by any LLM, and support both end-to-end and component-level evaluation. It also generates synthetic datasets, runs benchmarks like MMLU and GSM8K, and integrates with LangChain, LangGraph, CrewAI, OpenAI Agents, Pydantic AI and others.

Best for

• Python teams that want evals in their test suite
• RAG and agent metrics
• CI checks on LLM output quality

Use it when

You want LLM quality checks written as tests that run locally or in any CI environment.

Why you'd want it

LLM is Simon Willison's CLI tool and Python library for OpenAI, Claude, Gemini and dozens of other models, via remote APIs or models installed on your own machine. Plugins such as llm-anthropic, llm-gemini and llm-ollama add providers, and llm openai endpoint targets any OpenAI-compatible Chat Completions server without configuration. Prompts and responses are stored in SQLite, and it also generates embeddings, extracts structured content with schemas and lets models execute tools.

Best for

• Scripting LLM calls in the shell
• Comparing models from one CLI
• Keeping a searchable log of prompts

Use it when

You want quick model access from the terminal or a small Python library, with every prompt and response logged locally.

Why you'd want it

Repomix reads a local or remote repository, respects .gitignore and .repomixignore, uses Secretlint to leave out files that match known credential formats, and writes one file with a summary, directory structure and file contents, plus token counts per file. The --compress option uses Tree-sitter to keep key code elements with fewer tokens, and large outputs can be split into parts. It also runs as an MCP server (repomix --mcp) and can generate Claude Agent Skills from a codebase.

Best for

• Feeding a whole codebase to a chat model
• Checking token counts before sending context
• Packing a remote GitHub repo for reference

Use it when

You want to hand an LLM a full or filtered snapshot of a repository in one file, or let an agent pack repos through MCP.

Why you'd want it

Strands is an SDK for cases where you would otherwise write your own agent loop: it runs in your process with no hosted control plane and covers turn limits, token budgets, cancellation, tools, structured output, MCP, multi-agent patterns, memory, sessions, streaming, guardrails, tracing and evals. It has first-class support for Amazon Bedrock, Anthropic, OpenAI and Gemini plus other and custom providers, and hooks let you intercept any step of the loop. Strands harness (create_harness() in Python, createHarness() in TypeScript) gives a fully assembled agent with preset defaults.

Best for

• Replacing a hand-rolled agent loop
• Amazon Bedrock users
• Mixed Python and TypeScript stacks

Use it when

You want to own the agent loop in your own process, with lifecycle limits, hooks and tracing built in and the option to swap model providers.

Why you'd want it

The repo ships two ByteDance projects. UI-TARS Desktop is a desktop app with a native GUI agent driven by the UI-TARS and Seed-1.5-VL/1.6 vision-language models: it takes screenshots, recognizes what is on screen and controls the mouse and keyboard to follow natural-language instructions, with local computer and browser operators. Agent TARS is a separate CLI and Web UI agent that controls browsers through visual grounding, the DOM or a hybrid of both, and can mount MCP servers to reach other tools.

Best for

• Experimenting with vision-based computer use
• Automating desktop apps that have no API
• Running an open GUI agent model you deploy yourself

Use it when

You want an agent that operates desktop apps or a browser by looking at the screen, and you can point it at a UI-TARS model endpoint, for example one deployed on Hugging Face.

Why you'd want it

Steel is an open-source browser API server: it manages sessions, pages and Chrome processes so your agent code connects to a ready browser with Puppeteer, Playwright or Selenium. Sessions keep cookies and local storage across requests, and the server includes proxy chain management, custom Chrome extensions, stealth plugins and fingerprint management, and a UI for viewing and debugging sessions. Quick action endpoints return a page's HTML, a screenshot or a PDF in one REST call, and the Node and Python SDKs work against both self-hosted Steel and Steel Cloud.

Best for

• Hosting your own browser infrastructure for agents
• Stateful sessions with proxies and extensions
• Teams already using Puppeteer, Playwright or Selenium

Use it when

Your agent needs remote, stateful browser sessions and you want to run them yourself in Docker or use the managed Steel Cloud.

Why you'd want it

Inspect, from the UK AI Security Institute and Meridian Labs, builds evaluations from composable datasets, solvers (from a single generate call to multi-turn agents with tools) and scorers, and runs them with inspect eval. It supports custom and MCP tools plus built-in bash, python, web browsing and computer tools, can evaluate external agents like Claude Code, Codex CLI and Gemini CLI, and sandboxes untrusted model code in Docker, Kubernetes, Modal and other systems. It ships over 200 pre-built benchmark evals, support for over 20 model providers, the Inspect View log viewer and a VS Code extension.

Best for

• Benchmarking models and agents
• Agentic evals that run code in sandboxes
• Research and safety evaluation teams

Use it when

You want to measure how a model or agent performs on a task suite, including agentic tasks with tools and sandboxed code, and compare results across providers.

Why you'd want it

Letta (formerly MemGPT) is now built as Letta Code, an agent harness whose agents keep memory, identity and conversation history and improve by rewriting their own memory blocks, skills and prompts. All context, including memory blocks, is tracked in git (MemFS), and agents can search past messages, call subagents and run on schedules. You reach the same agent from a terminal UI, a desktop app for macOS, Windows and Linux, chat.letta.com, or Slack, Telegram and Discord, with agent state stored in Letta Cloud or kept local.

Best for

• Long-running personal or team agents
• Agents that should learn from past sessions
• Using one agent across terminal, desktop and chat apps

Use it when

You want a ready-made agent that remembers and adapts over long periods, rather than a memory library to wire into your own agent.

Why you'd want it

smolagents keeps abstractions minimal: the agent logic fits in roughly 1,000 lines, and its CodeAgent writes its actions in code. It is model-agnostic (local transformers or Ollama models, Hugging Face inference providers, or OpenAI, Anthropic and others via LiteLLM) and can use tools from MCP servers, LangChain or Hub Spaces. Agents and tools can be pushed to and pulled from the Hugging Face Hub, and a smolagent CLI runs agents from the terminal.

Best for

• Agents that act by writing code
• Hugging Face Hub users
• Reading and learning a compact agent loop

Use it when

You want a small, readable agent library and agents that act by writing code, with your choice of local or hosted models.

Why you'd want it

Stripe hosts an MCP server at mcp.stripe.com with OAuth; its tools search, inspect, read and write Stripe API methods and search the Stripe docs, which makes much of the API reachable without loading every endpoint into context. Stripe requires human confirmation before some write actions, such as refunds and outbound payments. The stripe/ai repo also holds the Agent Toolkit for Python and TypeScript (OpenAI Agents SDK, LangChain, CrewAI, Vercel AI SDK), a local MCP package, billing integrations for the Vercel AI SDK and native OpenAI, Anthropic and Gemini SDKs, and Stripe agent skills and plugins.

Best for

• Products built on Stripe
• Agent frameworks that need Stripe tools via function calling
• Looking up Stripe docs while integrating

Use it when

You build on Stripe and want a coding agent or your own agent to query and change Stripe objects, or to answer integration questions from the Stripe docs.

Why you'd want it

Exa hosts the server at mcp.exa.ai/mcp and it works without an API key under rate limits, so setup is a URL or a plugin install. The default tools are web_search_exa, which returns clean content for search results, and web_fetch_exa, which reads pages as markdown; advanced search with domain and date filters and Exa Agent runs for multi-step research can be turned on with the tools URL parameter. The repo also ships search and exa-agent skills that load with plugin installs.

Best for

• Coding agents that need current web results
• Multi-step research and list-building
• Improving built-in web search in Claude, ChatGPT or Codex

Use it when

Your agent needs to search the web or read pages as clean markdown and you want a hosted server with nothing to install.

Why you'd want it

LangSmith is LangChain's platform for debugging, evaluating and monitoring language model apps and agents; the MIT-licensed Python and JavaScript SDKs send traces to it, for example by wrapping the OpenAI client. It works with any LLM application and has a native integration with LangChain Python and LangChain JS. There is a free Developer plan with a monthly trace allowance and paid per-seat plans, with pay-as-you-go usage beyond the included traces.

Best for

• Teams already building with LangChain
• Hosted tracing without running infrastructure
• Python and JS/TS apps

Use it when

You want managed tracing and evals with no servers to run, especially if your app already uses LangChain.

Why you'd want it

Sentry runs a remote MCP server at mcp.sentry.dev that uses OAuth and acts as middleware to the Sentry API, with tools chosen for debugging workflows in coding assistants rather than full Sentry coverage. You can scope the connection to one organization or project, which sets defaults and hides discovery tools. For self-hosted Sentry there is a stdio transport (npx @sentry/mcp-server) that takes a user auth token; its AI-powered search tools need an OpenAI, Azure OpenAI, Anthropic or OpenRouter key.

Best for

• Teams already on Sentry
• Debugging production errors from the editor
• Self-hosted Sentry via the stdio transport

Use it when

Your app reports to Sentry and you want the coding agent to pull issue details, errors and traces while it works on a fix.

Why you'd want it

Cursor is a desktop editor with an agent that searches and reads your repo, makes multi-file changes and shows them as diffs to review. Plan Mode researches the codebase, asks clarifying questions and waits for your approval before building, and the same Agent, Plan and Ask modes are available in the Cursor CLI. Premium and higher plans add Cloud Agents that keep running while you are away, Automations and Bugbot code review.

Best for

• Developers who want the agent built into the editor
• Moving work between editor, terminal and cloud agents
• Teams that want Bugbot code review

Use it when

You want one editor with the agent built in, plus a CLI and cloud agents that share the same modes and subscription.

Why you'd want it

Copilot is built into GitHub, so an issue can be picked up by an agent, come back as a pull request, get reviewed and be merged in one place. It runs in VS Code, Visual Studio, JetBrains IDEs, Eclipse and Xcode, in a terminal CLI, in the GitHub Copilot app, on github.com and in GitHub Mobile, and it accepts custom instructions, agent skills, custom agents and MCP servers. Organization admins control access, feature policies, file exclusions and audit logs.

Best for

• Teams whose work already lives on GitHub
• Organizations that need admin policies and audit logs
• Developers spread across many IDEs

Use it when

Your code, issues and pull requests are on GitHub and you want agent work and code review tied into that workflow.

Why you'd want it

OpenRouter exposes hundreds of models behind a single /api/v1/chat/completions endpoint, handles fallbacks automatically and picks the most cost-effective provider for each request. Existing OpenAI SDK code works by pointing the base URL at OpenRouter, and there are also typed client SDKs for TypeScript and Python plus an Agent SDK. It passes through provider pricing without markup, charges a fee when you buy credits, and supports bringing your own provider keys.

Best for

• Switching between models without code changes
• Comparing models from many providers
• Apps that need provider fallbacks

Use it when

You want one API key and one endpoint for models from many providers, with routing and fallbacks handled for you.

Why you'd want it

Container Use is an MCP server, run from a CLI and built on Dagger, that gives each agent a fresh container on its own git branch, so you can run several agents at once and discard failed attempts. You can see the full command history and logs of what an agent did, drop into its terminal to take over, and review its work with a normal git checkout of its branch. Setup is the same for any MCP-compatible agent, adding container-use stdio as an MCP server, and the docs have guides for Claude Code, Cursor, Windsurf, Zed, Codex, Gemini CLI and others.

Best for

• Running several coding agents in parallel
• Keeping agent changes off your working tree until reviewed
• Claude Code, Cursor and other MCP agents

Use it when

You want coding agents to work in isolated, reviewable environments on your own machine instead of directly in your checkout.

Why you'd want it

Daytona sandboxes are full computers with a dedicated kernel, filesystem, network stack and allocated vCPU, RAM and disk, which agents create and control through SDKs for TypeScript, Python, Ruby, Go and Java, an API and a CLI. Operations cover sandbox lifecycle, file system, process and code execution and git, and stateful snapshots let agent work persist across sessions. The docs also cover computer use, an MCP server, and SSH, VNC and web terminal access, and the pricing page lists GPU options.

Best for

• Agents that need sandboxes that persist across sessions
• SDK users in Ruby, Go or Java as well as Python and TypeScript
• Sandboxed workloads that need GPUs

Use it when

You want hosted, isolated machines for agent code execution and prefer usage-based billing to running the infrastructure yourself.

Why you'd want it

Aider builds a map of your whole codebase so it can work in larger projects, and it commits its changes to git with descriptive messages so you can diff and undo them with normal git tools. It connects to most cloud LLMs and to local models, can lint and test after every edit and fix what fails, and also takes requests from comments you add in your editor. Images, web pages and voice input can be added to the chat.

Best for

• Git-centric terminal workflows
• Bring-your-own-model setups, including local models
• Editing existing codebases

Use it when

You want an agent that records every change as a git commit and lets you choose the model provider, including local models.

Why you'd want it

AutoGen is Microsoft's multi-agent framework, layered into a Core API (message passing, event-driven agents, local and distributed runtimes), an AgentChat API for common patterns such as two-agent chat and group chat, and an Extensions API for model clients and code execution. AutoGen Studio adds a no-code GUI for prototyping multi-agent workflows, though the README says it is not meant to be a production-ready app. Existing users can keep using it, but it no longer receives new features.

Best for

• Maintaining existing AutoGen projects
• Studying multi-agent orchestration patterns

Use it when

You already run AutoGen and need it to keep working while you plan a migration.