The agent stack.

Sourcegraph's agentic coding tool, built around large-codebase context.

Built by people who spent a decade on code search, and it shows on big repos where naive context-stuffing falls over.

Anthropic's terminal-based coding agent, with MCP support and IDE extensions.

The most capable agent for long, multi-file work. MCP support is first-class, which is what lets it pull project state instead of being re-briefed each session.

OpenAI's coding agent, available in CLI and cloud forms.

Worth having as a second opinion — a different model family fails differently, which is useful when one agent is stuck in a loop.

AI-native IDE built on VS Code, with an agent mode for multi-file edits.

The best on-ramp if you want the agent inside an editor you already know. Strongest when you're reviewing every diff rather than running unattended.

Autonomous software engineer that works asynchronously on assigned tasks.

The most autonomous option, and the one that most needs a well-defined task. Vague input is expensive here in a way it isn't in an interactive agent.

Agentic IDE focused on multi-step autonomous edits. Windsurf now ships as Devin Desktop under Cognition.

Leans further toward autonomy than Cursor. Good when tasks are well-specified up front — which is exactly what a proper scope gives you. If you are searching for Windsurf, this is where it went.

Open-source terminal coding agent, provider-agnostic.

The one to reach for when you want to bring your own model or run entirely on your own keys. No lock-in to a single provider's pricing.

High-performance collaborative editor with built-in AI agent support.

Fastest editor of the bunch by a wide margin. Agent support is newer than Cursor's but the collaboration model is genuinely better.

Elaborate animated React components for marketing pages.

Heavier and flashier than Magic UI. Good for landing pages where the animation is the point; overkill inside an app.

Vercel's shadcn-based component library for AI apps — chat, code, voice, workflow.

If you're building anything with a chat or agent interface, start here instead of rebuilding message lists and streaming states. Purpose-built for the AI SDK, with streaming and status handling already correct.

Curated collection of polished UI components.

Good source of visual reference when you know the layout you want but not what to call it.

Component collection aimed at modern web apps.

Another copy-in library worth checking when shadcn doesn't have the primitive you need.

Animated components and effects, shadcn-compatible.

Where you go for motion without hand-writing animation code. Same copy-in model as shadcn, so agents handle it well.

Distinctive UI components and patterns.

Leans unusual on purpose — useful when everything built from the same three libraries has started to look identical.

Copy-paste React components built on Radix and Tailwind.

The default for agent-built UI, and the reason is structural: components are copied into your repo as source, so an agent can read and modify them. Imported component libraries are opaque to agents in a way this isn't.

Pre-built page sections and blocks built on shadcn/ui.

Section-level rather than component-level, which is the right altitude for an agent assembling a marketing page in one pass.

A library of web transition and animation patterns.

Useful as a reference to point an agent at when 'make it feel smoother' needs to become a specific, nameable technique.

Official MCP server for GitHub — issues, PRs, code search, actions.

The bridge between agent work and where your team actually reviews it. Most useful for letting an agent read issue context before it starts.

The open protocol for connecting AI agents to tools and data sources.

Worth understanding directly rather than only through the tools that implement it — knowing what the protocol can express tells you what's worth building.

Browser automation for agents via MCP.

Gives an agent eyes on the running app. The difference between 'the code compiles' and 'the button actually works'.

Gives any MCP client live read/write access to your project scope.

Our own — agents pull the current plan, claim the next ready task, and report status back, so every session starts caught up instead of cold.

MCP server for Supabase — schema, queries, migrations, logs.

Lets an agent inspect your actual schema instead of guessing at it from migration files. Cuts a whole class of wrong-column bugs.

Task-specific instruction files an agent loads on demand, in a shared vendor-neutral directory.

The companion to AGENTS.md: that file carries always-on repo rules, skills carry deeper instructions loaded only when relevant. Keep them in .agents/skills/ rather than .claude/ or .cursor/ — a per-tool copy is a per-tool source of truth, and they diverge the moment two people edit them.

The vendor-neutral standard for repo-level agent instructions, read by Codex, Cursor, Amp, Zed, Jules and others.

Use this, not a tool-specific file. One set of rules every agent reads is the difference between a team that agrees and a team where each person's agent believes something different. Point CLAUDE.md at it with a single @AGENTS.md line rather than maintaining two copies. Best for stable facts — stack, conventions, commands; anything that changes weekly belongs in a live plan instead.

Up-to-date library documentation delivered to agents via MCP.

Fixes the specific failure where an agent writes confident code against a library version that shipped two years ago.

Packs a repository into a single AI-friendly file.

Handy for one-shot analysis in a chat window when you want a whole small repo in context at once.

Turns a rough idea into a structured, agent-ready project scope agents query over MCP.

Our own. The plan is the source of truth: agents read the current scope and write progress back, so context survives between sessions and across harnesses.

Model and harness rankings from real agent usage rather than synthetic suites.

Ranked on tasks agents actually ran — what got done, what it cost, how long it took. A far better signal than benchmark scores for picking a model to run in a loop.

Broad community-maintained directory of AI developer tools.

Where to go when you want breadth rather than a shortlist — hundreds of tools across 20+ categories, community-submitted via GitHub.

TypeScript toolkit for building AI apps with a unified provider interface.

The standard way to talk to models from TypeScript. Provider-agnostic, so switching models is a config change rather than a rewrite.

Evaluation and observability platform for AI applications.

The moment you have more than one prompt in production, you need to know whether a change made things better. This is that.

Managed development environments for agents and humans.

Useful when agents need a full dev environment rather than a bare sandbox — dependencies, services, the lot.

Secure cloud sandboxes for running AI-generated code.

What you need before letting an agent execute code it wrote. Isolation you don't have to build yourself.

Open-source LLM observability, tracing, and cost tracking.

Self-hostable tracing — the fastest way to find out why an agent run cost $40 instead of $4.

One endpoint for 300+ models across 25+ providers, at provider list prices.

Swap models without touching code, and no markup over list rates. It's also the pricing source behind our model comparison page.

In-browser full-stack app generation and deployment.

Runs the whole toolchain in the browser, so there's nothing to install. Handy for validating an idea before committing a repo to it.

Prompt-to-fullstack-app builder with live preview.

Good for getting a full app shape fast. Plan on exporting and taking over in a real agent once it's past prototype.

Cloud IDE with an AI agent that builds and deploys full applications.

The deployment story is the differentiator — it goes from prompt to a running, hosted app without you touching infrastructure.

Vercel's generative UI tool — prompt to React components.

Best-in-class for going from a description to a working React component. Output is shadcn-flavoured, so it drops into an existing codebase cleanly.