88 components across 10 layers, 59 of them open source. Hand-curated, which means it is opinionated and it will drift — every entry links to its own docs so you can check.
Anthropic's coding agent — terminal, IDE and SDK, with hooks, skills and MCP built in.
The Claude Code loop as a library, for agents that are not about code.
Self-improving agent from Nous Research — writes its own skills from experience and carries them forward.
Self-hosted gateway putting an agent in Slack, Telegram, WhatsApp, Signal, Discord and iMessage at once.
Prime Intellect's recursive-language-model harness — a persistent IPython kernel is the only tool, sub-agents are function calls.
Everything is a plugin — the model adapter, the tool registry, the sandbox and the agent loop itself are all swappable.
Lightweight loop with handoffs, guardrails and sessions.
OpenAI's terminal coding agent.
Open-source terminal coding agent, provider-agnostic.
Block's open-source on-machine agent with an extension system.
Stateful agent server where memory is the primary abstraction.
No harness. A while-loop, a model call and your own tool dispatch.
Claude Opus, Sonnet and Haiku. Strong tool use and long-horizon agentic work.
GPT and o-series via the Responses API.
Gemini models with very long context and native multimodality.
Frontier models inside your AWS account, with IAM and VPC boundaries.
Claude and Gemini under GCP billing, IAM and regional controls.
Strong reasoning and coding at a fraction of frontier pricing, with the weights published so you can move off the API later.
One API key, several hundred models, automatic failover.
One OpenAI-compatible endpoint routed across Groq, Together, Fireworks, Cerebras and Replicate — with the open-weight catalogue behind it.
Hosted open-weight inference with no prompt logging or retention, plus an anonymising proxy in front of the frontier APIs.
Self-hosted proxy that speaks one API to 100+ providers, with keys and budgets.
Open-weight models at very low latency.
Open-weight models on your own machine. Nothing leaves the box.
High-throughput open-weight serving on your own GPUs.
Graph-shaped orchestration with checkpointing, interrupts and human-in-the-loop.
TypeScript agent framework with workflows, memory, evals and a local playground.
Type-safe Python agents with structured output that actually validates.
Role-based crews of agents with delegation between them.
Fast, lightweight multi-agent runtime with built-in memory and knowledge.
Data-first framework — ingestion, indexing and RAG-heavy agents.
Programs, not prompts — compile and optimise the prompt against a metric.
Streaming-first TypeScript SDK with a unified provider interface and UI hooks.
Extracts durable facts from conversations and recalls them on the next turn.
Temporal knowledge graph memory — facts with validity windows, not just embeddings.
Treats memory as a reasoning problem, not a retrieval one — you ask its Dialectic API a question about the user and get a synthesised answer.
Memory graph plus automatic user profiles, with connectors that sync from Drive, Gmail, Notion and GitHub.
Memory primitives that plug straight into LangGraph checkpoints.
Builds a graph + vector memory layer over your agent's history and documents.
A messages table and a summaries table. Boring, auditable, yours.
Vector search inside the Postgres you already run.
Rust vector database with strong payload filtering, self-host or cloud.
Fully managed vector database. No index to operate.
Embedded vector store that runs in-process. Ideal first index.
Vector and full-text search on object storage — very cheap at rest.
Embedded multimodal store backed by the Lance columnar format.
Embeddings-native web search built for agents, with full-content retrieval.
Search API that returns model-ready answers rather than ten blue links.
Turns any site into clean markdown, including the JavaScript-heavy ones.
Independent web index with straightforward per-query pricing.
Self-hosted metasearch. No third-party search vendor in the path.
The open protocol for exposing tools and data to agents. The default answer.
Managed auth and tool-calling for 250+ SaaS apps.
Tool-calling with per-user OAuth, so the agent acts as the user, not as root.
Managed headless browsers with stealth and session replay, plus Stagehand.
Drive a real local browser over MCP, using the accessibility tree.
Open-source integration platform — you own the OAuth and the sync logic.
Open-weight classifier for input and output safety. Runs wherever you run it.
Declarative input/output validators with a hub of prebuilt checks.
NVIDIA's programmable rails — constrain topic, dialogue path and tool use.
Prompt-injection and jailbreak detection as a low-latency API call.
Open-source prompt-injection detector with canary tokens.
Policy engine and analyzer for agent traces and MCP tool calls.
Identity, delegated consent and scoped tokens for agents acting on behalf of users.
Token vault, async user approval and fine-grained authorization for tool calls.
Authorization-as-a-service — decide what this agent may touch, per record.
PII detection and redaction before text ever reaches a model provider.
Rate limiting, caching, spend caps and logging in front of any provider.
Default-deny egress firewall for untrusted workloads. The sandbox holds worthless proxy tokens; real credentials are swapped in at the boundary.
Google's user-space kernel. Intercepts syscalls before they reach the host, without paying for a full VM.
AWS microVMs — a separate Linux kernel per sandbox, booting in about 125ms.
MicroVM isolation behind the ordinary container API — drops into Kubernetes as a RuntimeClass.
The agent runs as an ordinary process on the host. Honest default only when it executes no code and reads nothing untrusted.
Open-source tracing, prompt management and evals. Self-hostable in one compose file.
Tracing, datasets and evals from the LangChain team.
Eval-first platform — scorers, datasets and a playground for prompt iteration.
OpenTelemetry-native tracing and evals you can run locally.
OpenTelemetry observability with first-class Python and Pydantic AI support.
Local eval and red-team harness that runs in CI. No account needed.
One file, one box, everything local. The honest starting point.
Streaming-friendly serverless for TypeScript agents with a web front end.
Edge runtime with Durable Objects for long-lived, stateful agent sessions.
Python-native serverless with GPUs and sandboxes, scale to zero.
Long-running containers close to users, without owning a Kubernetes cluster.
Firecracker sandboxes for running code the agent wrote, safely.
Durable execution — the run survives a crash, a deploy and a week of waiting.
Paradigm's self-hosted control plane: one shared team agent, an isolated k8s sandbox per Slack thread, and no raw API keys in the agent's environment.
Your existing cluster. Nothing new for the platform team to approve.
Every page here answers to Accept: text/markdown and returns the same content at roughly a tenth the tokens. No separate site, no toggle — same URL.
curl -s -H "Accept: text/markdown" https://newagent.build/providers