About This Catalog

This is the fourteenth volume in a catalog of the working vocabulary of agentic AI, and the first one that violates the catalog’s value proposition deliberately. Volumes 1—13 are structural vocabulary: patterns, mechanisms, and disciplines designed to outlast specific products. The value proposition has been explicit since Volume 1: products and frameworks change quickly; structural understanding holds up. This volume is the opposite. It documents specific products by name, with current state, market positions, and pricing where relevant. It is designed to be useful now and obsolete in 18 months. Reading it accordingly is the most important advice this volume can give.

Why include it anyway? Because architects in 2026 do need product knowledge alongside structural understanding. Knowing that the discipline of code execution sandboxing matters (Volume 12) is more durable than knowing that E2B, Modal, and Daytona are the dominant products as of mid-2026, but the architect making a procurement decision next week needs both. The structural volumes assume the reader has product knowledge from elsewhere and focus on the durable patterns; this volume provides that product knowledge in one place, with the explicit understanding that its accuracy decays quickly.

The volume’s timing reflects the genuine consolidation that has happened in some agent product categories through 2024—2026. Coding agents have moved from a Cambrian explosion of credible options in 2024 to roughly five production-grade winners in 2026. Agent frameworks have moved from many small frameworks competing to LangChain/LangGraph dominance with OpenAI Agents SDK as the established alternative. Some vertical agent categories (customer support, sales outreach) have established leaders; others (healthcare, finance, education) are still in flux. The snapshot captures this consolidation while acknowledging that the next consolidation cycle is probably already underway.

Scope

Coverage:

Provider-native agent offerings from Anthropic, OpenAI, Google and Meta, with the foundation model providers summarized in Appendix G.
Coding agents: Claude Code, Cursor, Devin Desktop (formerly Windsurf), Devin, GitHub Copilot, OpenAI Codex, Replit Agent, OpenCode, Cline, Aider, and the prompt-to-app builders (Lovable, Bolt.new, v0).
Agent frameworks: LangChain/LangGraph, Vercel AI SDK, Microsoft Agent Framework (successor to AutoGen), CrewAI, Pydantic AI. The OpenAI Agents SDK and Claude Agent SDK have their own entries in Volumes 9 and 18.
Vertical agent products: customer support (Decagon, Sierra, Fin), voice agents (ElevenLabs Agents, Vapi, Retell), legal (Harvey), research (Hebbia, Glean, Perplexity Enterprise). Sales agents (11x, Clay, Apollo) are listed in Appendix G.
Computer use and browser agents: Anthropic computer use and Claude in Chrome, OpenAI’s ChatGPT agent and computer-use tool, Browserbase.
Enterprise agent platforms: Salesforce Agentforce, Microsoft Copilot Studio, Google Gemini Enterprise, OpenAI Frontier.
Consumer AI assistants (ChatGPT, Claude.ai, Gemini, Perplexity, Grok) appear only as references in Appendix G.
Agent observability and ops platforms: LangSmith, Phoenix, Langfuse, Helicone, Braintrust, Galileo.

Out of scope:

Pricing details beyond order-of-magnitude. Specific prices change frequently; the volume cites order-of-magnitude where it affects decisions but not exact figures.
Comprehensive benchmark numbers. SWE-bench, MMLU, and other benchmark scores change with every model release; the volume cites them only where they reflect substantial competitive position.
Detailed product feature comparisons. Product features change weekly; the volume covers the strategic position of each product, not its feature matrix.
Detailed company analysis. Acquisitions, funding rounds, and corporate moves are tracked only where they’ve substantially affected the product landscape (e.g., the Windsurf saga).
Products that haven’t reached production deployment yet. The list of credible agent products that exist only as announcements is long; this volume covers products people are actually using in production.

How to read this catalog

Part 1 (“The Narratives”) is conceptual orientation: why this volume is different from the prior thirteen; the five product categories that organize the landscape; the build-vs-buy decision framework; the open-source vs. commercial pattern; and how to read product density for market signal. Five diagrams sit in Part 1.

Part 2 (“The Substrates”) is the product survey itself, organized by section. Each section opens with a short essay on what the products in that category share. Representative products appear in the Fowler-style template adapted for product entries: intent, motivating problem, how the product works, when to use it, sources for further reading. The depth varies; foundational products get more space than niche ones. The entries are product groupings, not reusable patterns: read them as a survey that sits beside the pattern vocabulary of the other volumes, not as part of it.

Part 1 — The Narratives

Five short essays frame how to read a snapshot of products in a rapidly-evolving market. The reference entries in Part 2 assume the perspective established here.

Chapter 1. Why This Volume Is Different

Volumes 1—13 are structural vocabulary. They document patterns, mechanisms, and disciplines designed to outlast specific products. When Volume 1 documents the ReAct pattern, that pattern works regardless of which framework implements it. When Volume 8 documents red-teaming, the discipline persists even as specific red-teaming tools come and go. The structural understanding is the value; the products are examples that illustrate the structure. This was the explicit proposition from Volume 1’s About section onward, and it’s held up: the prior volumes still read as useful structural references even as the specific products they cite have evolved.

Snapshot vs structural — Volumes 1–13 are structural vocabulary designed to age slowly. This volume is a snapshot designed to be useful now and obsolete in 18 months. Read it accordingly.

This volume violates the proposition deliberately. It documents specific products by name with current state, market position, and operational details. Six months from now some of the named products will have been acquired, deprecated, or substantially repositioned. Eighteen months from now the entire landscape will have evolved further, with new winners and losers the May 2026 snapshot can’t anticipate. The Windsurf saga of 2025 is a working example: OpenAI announced a $3 billion acquisition in May 2025; Microsoft’s IP rights blocked the deal; Google did a $2.4 billion reverse acqui-hire of the leadership in July 2025; Cognition acquired the remaining assets days later. A snapshot of “leading coding agents” in April 2025 would have shown Windsurf as an independent leader; the same snapshot in July 2025 would have shown Cognition’s portfolio. The structural vocabulary (“IDE-anchored AI coding agent”, “autonomous async coding agent”) held up across the transition; the specific product mapping changed substantially.

Why include this volume anyway? Because architects in 2026 do need product knowledge alongside structural understanding. Knowing that the discipline of agent observability matters (Volume 7 and Volume 12 cover this) is durable; knowing that LangSmith, Phoenix, Langfuse, Helicone, Braintrust, and Galileo are the working options as of mid-2026 is what the procurement team needs to know next week. The structural volumes assume the reader has product knowledge from elsewhere; this volume provides that knowledge in one place. The trade-off is the volume ages faster than its peers, and the reader should treat it as a snapshot rather than a settled reference.

Read this volume with three explicit understandings. First, the specific products will change; the categories and the strategic positions of categories should hold up longer than the individual products. Second, where this volume cites a leader in a category (“Claude Code, Cursor, and Windsurf dominate IDE-anchored coding”), the leader assertion is current but contingent; six months later the leaders may differ. Third, the structural understanding in the prior thirteen volumes is the durable layer; this volume is the perishable layer that gets refreshed. Treat the perishability as the price of the volume’s near-term usefulness, not as a flaw.

Chapter 2. The Five Product Categories

The agent product landscape as of mid-2026 organizes into five categories that interact predictably. Foundation models are the substrate everything else depends on. Agent frameworks are the build-your-own substrate for custom agents. Coding agents are the most mature vertical, with established leaders and visible consolidation. Vertical agents cover other specific domains at varying maturity. Ops platforms instrument all of the above. Understanding the categories separately makes the broader landscape legible.

Foundation models are the substrate. The major providers as of late 2026: Anthropic with the Claude family (Fable, Opus, Sonnet and Haiku tiers); OpenAI with the GPT-5.x line; Google with Gemini 3.x; Meta, which moved its frontier work to the closed Muse family in April 2026; DeepSeek and Qwen, now the leading open-weight families; xAI with Grok (xAI is part of SpaceX since February 2026). Each provider has its own positioning: Anthropic emphasizes safety and reasoning; OpenAI emphasizes broad capability and tool integration; Google emphasizes multimodality and integration with its ecosystem; the Chinese labs provide the open-weight options many self-hosted deployments default to. Model names change every few months, so check each provider’s models page rather than this paragraph. The choice among providers depends on the use case, the deployment constraints (cloud, on-premises, regional sovereignty), and the cost profile.

Agent frameworks are the build-your-own substrate. LangChain and its LangGraph orchestration layer dominate as the broadest-adopted framework. OpenAI Agents SDK (the successor to the Swarm experiment) is the OpenAI-native alternative. The Claude Agent SDK (renamed from the Claude Code SDK) is the Anthropic-native alternative. Vercel AI SDK is the web-developer-oriented option with first-class generative UI primitives (Volume 13 covers these). Microsoft Agent Framework (the successor to AutoGen) and CrewAI compete in the multi-agent orchestration space. Pydantic AI has emerged as a typed-Python option emphasizing structure and validation. The framework choice is one of the foundational decisions an agent team makes; later sections cover the trade-offs.

Coding agents are the most mature vertical and the canonical example of how an agent product category consolidates. Through 2024 the category had over twenty credible options; by mid-2026 the field has consolidated to roughly eight production-grade products, with five dominating: Claude Code (Anthropic), Cursor (Anysphere, acquired by SpaceX in 2026), Devin Desktop (the former Windsurf editor, rebranded by Cognition in June 2026), Devin (Cognition’s autonomous async option), GitHub Copilot (Microsoft’s enterprise default). OpenAI Codex (the GPT-5.x-powered coding agent), Replit Agent 4 (full-stack scaffolding), and OpenCode (open-source terminal) round out the eight. The category demonstrates the pattern: dozens of options at peak fragmentation, consolidation to a handful as the patterns stabilize, persistent niche players for specific use cases.

Vertical agents cover other specific domains at varying maturity. Customer support is the most consolidated vertical after coding: Decagon, Sierra, Fin (formerly Intercom, which Salesforce agreed to buy in June 2026), and a handful of others dominate the production market. Sales and marketing have established leaders (11x, Clay, Apollo with AI features). Legal AI is dominated by Harvey for big-firm legal work and a handful of others for specific niches. Research agents include Hebbia and Glean for enterprise, Perplexity (consumer and enterprise tiers), and AI-native research tools. Healthcare AI is highly fragmented and regulated; finance AI is consolidating around a few enterprise platforms. The vertical maturity varies; understanding which verticals have leaders vs. which are still in flux informs procurement strategy.

Ops platforms instrument the agents. LangSmith (LangChain’s commercial observability platform) is the leader for LangChain-based deployments. Phoenix (Arize’s open-source observability platform) and Langfuse (open source, part of ClickHouse since January 2026) compete for framework-agnostic observability. Helicone, Braintrust, and Galileo offer additional options with different specific emphases (Helicone on cost and caching, Braintrust on evaluation and prompt management, Galileo on enterprise governance). The category is consolidating through acquisitions (ClickHouse bought Langfuse, Cisco bought Galileo, Mintlify bought Helicone); LangSmith has the strongest position by ecosystem coupling, but multiple alternatives have real market share and the eventual winners aren’t decided.

Chapter 3. The Build-vs-Buy Decision

Every team deploying agents in production faces the same decision: use an existing vertical product, build on an agent framework, or build directly on a foundation model API. The decision shapes the product’s engineering, operational, and economic profile. The right choice depends on the use case, the team’s capabilities, and the time horizon. There’s no universal answer; understanding the trade-offs is the goal.

Buy the vertical product when your use case matches a vertical with established leaders. Customer support agents: Decagon, Sierra, Fin handle the well-understood patterns (deflection, agent assistance, autonomous resolution within specific scopes) with significant capability built in. Trying to build a customer support agent from scratch in 2026 means rebuilding what these products provide; the engineering effort is substantial and the marginal advantage uncertain. The same applies to other mature verticals: Cursor or Claude Code for coding-agent use cases where the team is doing engineering rather than building agent infrastructure; Harvey for legal AI where the regulated domain expertise matters; Glean or Hebbia for enterprise research where the existing product’s integration with corporate data sources is hard to replicate. Speed to value is the dominant consideration; customization beyond what the product allows is the dominant limitation.

Use an agent framework when the use case is custom but the patterns are well-trodden. Building a customer service agent for a specific industry vertical that existing products don’t serve well, or a research agent for a specific domain corpus, or a complex multi-step workflow agent for internal operations --- these cases need custom development but not from scratch. LangGraph for orchestration, OpenAI Agents SDK or the Claude Agent SDK for vendor-native development, Vercel AI SDK for web-front-end agents. The framework provides the structural primitives (tool calling, state management, conversation flow, observability); the team provides the use-case-specific logic. The trade-off is more engineering effort than buying a product but much less than building from scratch, with the framework’s constraints accepted as a cost of leverage.

Build from scratch (directly on the foundation model API) when the use case is genuinely novel or maximum control matters. Frameworks add abstraction overhead; sometimes the abstraction doesn’t fit the use case. Building directly on Anthropic’s Messages API, OpenAI’s Chat Completions API, or Google’s Gemini API gives full control over prompts, tools, conversation flow, and orchestration, at the cost of building all the framework’s features yourself. The pattern is appropriate when the team has deep expertise and the framework’s defaults don’t fit, or when the use case is novel enough that no framework has the right abstractions. The pattern is inappropriate when the team chooses it because frameworks “seem too complex” --- the complexity is usually the framework solving real problems the team will rediscover.

Most production deployments mix: buy where the vertical exists, framework where it doesn’t, raw API only where frameworks would add overhead without enough benefit. The discipline is matching each part of the system to the appropriate substrate. The anti-pattern is uniform choice: “we’ll use LangChain for everything” produces unnecessary complexity for parts that should have used products; “we’ll build everything from scratch” produces unnecessary engineering for parts that should have used frameworks. Mixed deployments are normal in 2026; the architectural discipline is choosing the right substrate per use case rather than imposing uniformity.

Chapter 4. Open Source vs. Commercial

The agent product landscape has a characteristic open-source-vs-commercial structure that shapes procurement and engineering decisions. Open source dominates frameworks, developer tools, and observability where customization matters. Commercial products dominate end-user verticals where the product is the deliverable. Hybrid models --- open-core libraries with commercial cloud, support, or enterprise features --- dominate the substantial middle where developer adoption and enterprise revenue need to coexist.

Open vs commercial — Open source for frameworks and infrastructure; commercial for end-user products; hybrid (open core + commercial cloud) for substantial middle.

Open source dominates in agent frameworks. LangChain and LangGraph are MIT-licensed; Microsoft Agent Framework (AutoGen’s successor) is open source; CrewAI is open-core; Pydantic AI is open source. The frameworks compete partly on developer experience, partly on patterns supported; the open-source nature is a baseline expectation. Commercial frameworks have struggled to gain adoption against the open alternatives; the closed-source agent framework pattern has been tried and largely failed because developers want to inspect and modify the orchestration code, not treat it as opaque infrastructure.

Open source also dominates developer tools and infrastructure. OpenCode and Aider (terminal coding agents) and Cline (open VS Code coding agent) compete with commercial coding agents on the open side. Phoenix (observability) is open-source from Arize; Langfuse offers open-source observability with a managed cloud. The patterns reflect developers’ preferences for tools they can inspect and modify, especially for infrastructure that touches their development workflow.

Commercial dominates end-user verticals. Coding agents at the productized end (Cursor, Devin and Devin Desktop, GitHub Copilot) are commercial. Vertical agents (Decagon, Sierra, Harvey, Hebbia) are commercial. Enterprise observability and management (LangSmith, Braintrust, Galileo) are commercial. The pattern reflects the economics: end-user products require sustained product engineering, sales, and support that open-source projects typically can’t sustain. The few exceptions (open-source vertical agents) tend to be either developer-tool-adjacent (where the user is also the developer) or specialized for use cases too narrow for commercial economics.

Hybrid models dominate the substantial middle. LangChain is open source; LangSmith (its commercial observability product) is paid. Langfuse is open-core; the cloud-hosted version is commercial. Vercel AI SDK is open source; Vercel’s broader platform monetizes the developer adoption. The OpenAI Agents SDK and the Claude Agent SDK are libraries from companies whose business is the underlying foundation model API. The pattern works because the open library drives adoption, which drives use of the commercial layer, which sustains the development of both. The hybrid model dominates in 2026 across categories where developer adoption matters but enterprise revenue is the sustaining business.

Two practical implications for procurement. First, for infrastructure that touches engineering workflow (frameworks, observability), strongly prefer open source or hybrid models where the open library is fully functional. The lock-in cost of commercial-only infrastructure compounds; the migration cost when products change is significant. Second, for end-user verticals, commercial products are usually the better choice because the open alternatives typically lack the sustained product engineering that production deployments require. The discipline is matching the licensing model to the role the product plays in the deployment.

Chapter 5. Reading Product Density for Market Signal

How many credible products exist in a category tells you something about the underlying problem and the market’s state. Crowded categories signal well-understood problems with established demand; consolidation is the predictable next phase. Maturing categories show consolidation already underway. Emerging categories have a few credible products but with significant gaps remaining. Sparse categories have few or no production products, signaling either a hard problem or a small market. Reading density correctly informs both procurement decisions (do you wait for consolidation or commit to a specific product) and strategic decisions (which categories are the right place to build).

Product density signals — Crowded categories signal mature problems with imminent consolidation; sparse categories signal hard problems or small markets.

Crowded categories have many viable products competing simultaneously. Coding agents in 2024 (over 20 credible options) is the canonical recent example; observability platforms (10+ credible options) and customer support agents (5+ credible options) are current examples. The signal is positive: the problem is well-understood, the market has established demand, and capable founders and investors are competing to address it. The signal is also temporal: consolidation typically follows within 18 months as the winners pull ahead and the stragglers fade or get acquired. Procurement strategy: pilot multiple options to learn what works; commit to a winner as consolidation becomes visible; avoid heavy investment in stragglers whose long-term future is uncertain.

Maturing categories have consolidation already underway. Agent frameworks in 2026 fit this pattern: LangChain/LangGraph is the dominant choice; OpenAI Agents SDK is the established alternative; Microsoft Agent Framework and CrewAI hold niche positions, and AutoGen itself moved to maintenance mode in 2025. The category isn’t finished consolidating (the eventual winners may shift), but it’s past the peak-fragmentation phase. Procurement strategy: pick a winner with reasonable confidence; the cost of being wrong is bounded because migration to a different winner remains possible as the category resolves.

Emerging categories have a few credible products but with significant gaps remaining. Vertical agents in healthcare, finance, education fit this pattern in 2026: some products exist, but the category isn’t yet covered comprehensively, the products themselves are still working out their core value proposition, and significant product churn is expected through 2027. Computer-use products and multi-agent platforms are other examples. Procurement strategy: pilot small, accept that the chosen product may be replaced, design integrations to be replaceable rather than deep.

Sparse categories have few or no production products. Scientific research agents, hardware control agents, ambient and embedded agent products fit this pattern in 2026. The signal is mixed: either the problem is hard (the technology isn’t ready, the integration challenges are unsolved) or the market isn’t large enough yet to support production products (the demand exists but at academic scale rather than commercial scale). Procurement strategy: typically wait or build internally; the cost of waiting is usually less than the cost of betting on a research-grade product not yet proven in production.

Two final observations. Categories shift between density levels over time. Coding agents were emerging in 2023, became crowded through 2024, and consolidated through 2025—2026. Reading density correctly requires reading it at the current moment, not at any earlier snapshot. And density doesn’t correlate cleanly with category importance. Some sparse categories matter enormously to specific industries but lack production products because the integration challenges are unsolved; the sparsity reflects technical or economic friction, not unimportance.

Part 2 — The Substrates

Seven sections survey the agent product landscape as of late 2026. Each section opens with a short essay on what its products share. Representative products appear in the Fowler-style template adapted for product entries.

Sections at a glance

Section A --- Provider agent offerings
Section B --- Coding agents
Section C --- Agent frameworks
Section D --- Vertical agent products
Section E --- Computer use and browser agents
Section F --- Enterprise agent platforms
Section G --- Agent observability and ops platforms

Foundation model providers, consumer assistants, sales agents and tracking resources are listed in Appendix G.

Section A — Provider agent offerings

Anthropic, OpenAI, Google, Meta: the agent products the model providers build on their own models

Foundation models are the substrate of the entire agent product landscape. Every agent product in subsequent sections depends on at least one foundation model API; many depend on multiple. The major providers in late 2026 are Anthropic, OpenAI, Google, Meta, DeepSeek and Qwen (the leading open-weight families), and xAI (part of SpaceX since February 2026). Model lineups change every few months, so this volume lists the providers and their model pages in Appendix G rather than describing current flagships here.

The providers also ship their own agent products on top of their foundation models. Anthropic ships Claude Code, Claude in Chrome, the computer use tool, the Skills system, and MCP. OpenAI ships ChatGPT (with agent mode), GPTs, Codex, and Frontier for enterprise agents. Google ships the Gemini app, Gemini Code Assist, Jules, Antigravity, Gemini Enterprise and AI Studio. These provider-native products typically have the deepest integration with the underlying models but may have less product polish than dedicated startup products in specific verticals.

Pattern · 1 of 13

Provider-native agent offerings

Pattern page →

Classification Agent products built directly by foundation model providers on their own models.

Source: Anthropic Claude Code and Claude in Chrome, OpenAI ChatGPT agent and Codex, Google Jules and Antigravity, Meta AI

Intent

Provide turnkey agent capabilities on top of foundation models, with deep integration that third-party products typically can’t match, covering coding (Claude Code, Codex, Gemini Code Assist, Jules, Antigravity), computer use (Anthropic’s computer use tool and Claude in Chrome, ChatGPT agent mode), and general assistance (ChatGPT, Claude.ai, Gemini).

Motivating Problem

Foundation model providers are the most direct path from research breakthrough to production agent capability. When the provider ships an agent product on its own model, the integration is typically tighter than third-party products can achieve because the provider can access internal model capabilities and ship updates without coordinating with external partners. The trade-off is that provider-native products typically lack the vertical depth and customization that specialized startup products provide.

How It Works

Anthropic’s agent product line includes Claude Code (the terminal-native coding agent), Claude in Chrome (browser-based agent for web tasks), Computer Use (the API and tooling for desktop automation), Skills (the system for packaging agent capabilities as reusable units), and MCP (Model Context Protocol for tool integration). The products share Claude as the underlying model and Anthropic’s tool-use infrastructure.

OpenAI’s agent product line includes ChatGPT (the consumer assistant, with agent mode for computer and browser tasks), GPTs (custom configurations of ChatGPT), Codex (the coding agent across CLI, IDE, cloud and desktop), and Frontier (an enterprise platform for building and managing agents, launched February 2026). Operator (2025) and the Atlas browser (2025-2026) were folded into ChatGPT and Codex. The products share GPT-5.x as the underlying model and integrate with OpenAI’s tool calling and structured output capabilities.

Google’s agent product line includes the Gemini app (consumer assistant), Gemini Code Assist (coding agent integrated with Google Cloud), Jules (async cloud coding agent), Antigravity (agentic IDE and CLI, which absorbed Gemini CLI in May 2026), Gemini Enterprise (formerly Agentspace), and AI Studio (developer platform). Google’s products emphasize integration with Google’s broader ecosystem.

Meta’s positioning has shifted. Through 2025 it shipped open-weight Llama models that other developers built agent products on. In April 2026 Meta Superintelligence Labs released Muse Spark, a closed model that now powers Meta AI across WhatsApp, Instagram and Facebook, with open releases of later Muse versions promised. Llama 4 remains available but is no longer the default open-weight substrate.

Trade-offs: provider-native products typically have deeper integration with their underlying models but less customization than framework-based development. They benefit from updates as the underlying models improve; they suffer from being tied to one provider’s capability evolution. For use cases that fit the provider-native product’s shape, the depth of integration is often decisive; for use cases that don’t fit, framework-based development or different products are usually better choices.

When to Use It

Use cases that fit the provider-native product’s shape and benefit from deep integration with the underlying model. Coding (where Claude Code, Codex, and Gemini Code Assist are all credible options). General assistance (where ChatGPT, Claude.ai, and Gemini dominate). Computer use (Anthropic’s computer use tool and Claude in Chrome, ChatGPT agent mode and the computer-use tool in OpenAI’s Responses API, Google’s Gemini computer-use model). Use cases requiring vertical depth or significant customization are usually better served by specialized startup products or framework-based development.

Alternatives --- specialized startup products with vertical depth (next sections). Framework-based development for custom use cases. Multi-provider agent platforms for cases where provider-specific lock-in matters.

Sources

anthropic.com/news for product announcements
openai.com/blog for OpenAI product announcements
ai.google.dev for Google AI product documentation
jules.google, antigravity.google

Section B — Coding agents

The most mature agent vertical --- consolidated from twenty-plus options to roughly eight winners

Coding agents are the most mature agent product category in mid-2026. The category demonstrates the full consolidation cycle: from a Cambrian explosion of 20+ credible products through 2024, to consolidation around eight production-grade winners by mid-2026. The winners divide into three subcategories. IDE-anchored pair programmers (Cursor, Devin Desktop, GitHub Copilot) sit alongside the developer in the editor. Terminal-native and CLI agents (Claude Code, OpenCode, OpenAI Codex CLI, Aider) work in shell environments for deeper multi-file work. Autonomous task delegation agents (Devin, OpenAI Codex cloud, Replit Agent 4, Google Jules, the GitHub Copilot coding agent) run async in cloud environments, taking complete tasks and producing pull requests. The choice among them depends on workload shape and the team’s tolerance for autonomous vs. supervised work. A fourth group, the prompt-to-app builders (Lovable, Bolt.new, v0), serves people who do not write code at all.

Pattern · 2 of 13

Claude Code, Cursor, Windsurf, GitHub Copilot — the supervised pair-programming tier

Pattern page →

Classification Coding agents that work alongside developers in supervised pair-programming mode.

Source: Anthropic Claude Code; Cursor (Anysphere, acquired by SpaceX in 2026); Windsurf, now Devin Desktop (Cognition); GitHub Copilot (Microsoft/GitHub)

Intent

Provide coding assistance that augments developer productivity through inline suggestions, multi-file edits, agentic task completion, and codebase-aware reasoning, with the developer reviewing each suggestion or task in real-time supervision mode.

Motivating Problem

Coding is the agent vertical where the value proposition is clearest: developers spend most of their time on code; even modest productivity improvements compound to significant time savings; the supervised pair-programming pattern fits how developers already work. The four products in this entry are the supervised-mode leaders as of mid-2026, with established adoption across professional engineering teams. Each takes a different position on the interaction surface (terminal vs. IDE) and the model strategy (proprietary integration vs. multi-model).

How It Works

Claude Code: Anthropic’s coding agent, which started as a command-line tool and now also runs in IDE extensions, the desktop app and on the web. Frontier models now resolve most SWE-bench Verified tasks, so that benchmark is near saturation and SWE-bench Pro is the harder reference; check a dated leaderboard rather than a figure quoted here. Deep MCP integration. Pair-programming pattern: developers run claude in their project directory, ask it to make changes, review the proposed diffs, and apply them. Best for complex multi-file work where the deep context matters.

Cursor: IDE-anchored coding agent built as a VS Code fork. The dominant IDE-native option through 2025—2026. Strong inline completion, its own Composer models, an Agents Window for running parallel local and cloud agents, and Bugbot for PR review and autofix. SpaceX agreed to buy Anysphere in June 2026 for about $60 billion in stock and closed the deal in August 2026. Cursor changed to credit-based billing in June 2025, which has shifted some heavy users to alternatives. The IDE form factor fits developers who prefer not to leave their editor.

Windsurf, now Devin Desktop: AI-native IDE from Codeium, which launched the Windsurf Editor in November 2024 and renamed itself Windsurf in April 2025. Cognition acquired it in July 2025 after the Windsurf saga (OpenAI’s $3B acquisition blocked by Microsoft IP issues; Google’s $2.4B reverse acqui-hire of the leadership; Cognition acquiring the remaining assets) and rebranded the editor as Devin Desktop in June 2026, folding it into the Devin product line. Cascade is the differentiating agent feature, providing deep automatic codebase context. Pricing is competitive with Cursor.

GitHub Copilot: Microsoft’s coding assistant and agent, with tens of millions of users including free and student accounts, 4.7M paid subscribers as of January 2026, and use at more than 90% of the Fortune 100. The enterprise default. It offers a choice of Claude, Gemini and GPT models and an async coding agent that works from GitHub issues. Less aggressive than Cursor or Claude Code on the agentic frontier but with deeper enterprise integration (GitHub-native, supports for organizational policies, broad procurement availability). Teams that outgrow Copilot typically move to Cursor or Claude Code; teams that don’t outgrow it usually stay because the enterprise integration is hard to replicate.

When to Use It

Pick Claude Code for complex multi-file work where deep MCP integration and reasoning capability matter. Pick Cursor for IDE-native pair programming with broad feature surface. Pick Devin Desktop (formerly Windsurf) for codebase-context-aware AI assistance at a price point competitive with Cursor, or when the team also uses Devin. Pick GitHub Copilot for enterprise environments where Microsoft/GitHub integration matters more than cutting-edge capability.

Alternatives --- the autonomous async tier (next entry) for tasks suitable for delegation. Open-source coding agents (OpenCode, Cline, Aider) for cases where cost or open-source matter more than polish.

Sources

claude.ai/code, cursor.com, devin.ai/desktop, github.com/features/copilot

Pattern · 3 of 13

Devin, OpenAI Codex, Replit Agent — the autonomous async tier

Pattern page →

Classification Coding agents that run autonomously in cloud environments, taking complete tasks and producing pull requests.

Source: Cognition Devin; OpenAI Codex (GPT-5.x-powered coding agent); Replit Agent 4

Intent

Provide async coding capability where the developer delegates entire tasks (a ticket, a bug fix, a feature implementation) and the agent plans, implements, tests, and submits a PR with minimal supervision, fitting workflow patterns where the alternative would be a junior engineer.

Motivating Problem

The supervised pair-programming tier addresses interactive development. The autonomous tier addresses a different pattern: delegation of complete tasks to be worked on in the background. The use cases are different (repetitive refactors, migrations, dependency upgrades, well-defined feature work) and so are the operational considerations (review of the produced PR rather than real-time supervision, longer time horizons per task, integration with ticketing systems). The autonomous tier is younger than the supervised tier and the products are less consolidated, but the pattern is established enough for production use.

How It Works

Devin: the most autonomous of the coding agents. Each Devin instance runs in a fully sandboxed cloud environment with its own IDE, browser, terminal, and shell. The developer assigns a task (“fix this bug”, “implement this feature”); Devin plans, writes, tests, debugs, and submits a PR with minimal intervention. Devin 2.0 (April 2025) added Interactive Planning and Devin Wiki (auto-indexed repository architecture docs) and cut entry pricing from $500/month to $20. In April 2026 Cognition replaced the Core and Team plans with Free, Pro, Max, Teams and Enterprise plans (see devin.ai/pricing). Since June 2026 Cognition also ships the former Windsurf editor as Devin Desktop, so the same vendor covers both the supervised and the autonomous tier. Best for delegating complete tasks and walking away; less suited for tasks requiring tight collaboration.

OpenAI Codex (the 2025-2026 reincarnation): one agent across the CLI, IDE extension, cloud tasks and the desktop app (reported in July 2026 to have become a mode of the ChatGPT desktop app), powered by GPT-5.x-Codex models. Cloud task-runner pattern: define a task, run it in OpenAI’s managed environment, receive a PR. More integrated with OpenAI’s broader tooling than Devin. Strong on certain benchmark dimensions (SWE-bench Pro reaches mid-50s range; Terminal-Bench 2.0 above 75%).

Replit Agent 4 (March 2026, adding a design canvas, parallel agents and Plan mode): full-stack scaffolder with hosted runtime. The pattern fits projects that need scaffolding plus immediate deployment to a hosted environment; less suited for complex enterprise codebases. Strong for prototyping and rapid product iteration where the deployment infrastructure is part of the value proposition.

Newer entrants in the tier include Google Jules, the GitHub Copilot coding agent and Cursor’s cloud agents. Volume 4, Background coding agent platforms, covers the trigger shape these products share.

Use cases that fit autonomous coding agents: migrations (Nubank used Devin to migrate a multi-million-line ETL monolith, with Cognition reporting 8-12x efficiency gains and 20x cost savings on the delegated work); dependency upgrades; repetitive refactors; well-defined feature work that doesn’t require continuous architectural discussion. Use cases that don’t fit: interactive development requiring tight human-AI collaboration; tasks with significant ambiguity in requirements; debugging where the diagnosis requires extensive context-building.

When to Use It

Tasks suitable for delegation rather than interactive collaboration. Backlogs of well-defined work (migrations, upgrades, repetitive refactors). Teams with strong PR review discipline who can productively review async output. Use cases where the agent’s autonomy is a feature (the team doesn’t want to supervise) rather than a limitation.

Alternatives --- the supervised pair-programming tier for interactive development. Open-source alternatives where commercial pricing is the limitation. Custom agent development on frameworks where the team has specific requirements that productized agents don’t meet.

Sources

devin.ai, devin.ai/customers/nubank, openai.com/codex, replit.com/agent4

Pattern · 4 of 13

Open-source coding agents (Aider, Cline, Continue, OpenCode)

Pattern page →

Classification Open-source coding agents competing with commercial alternatives on cost, transparency, and customization.

Source: OpenCode (github.com/anomalyco/opencode); Cline (github.com/cline/cline); Aider (github.com/Aider-AI/aider); Continue (continue.dev, no longer maintained)

Intent

Provide credible open-source alternatives to commercial coding agents for teams or individuals who prioritize cost, inspectability, or customization over commercial polish.

Motivating Problem

Commercial coding agents have substantial budgets for product development and may charge accordingly. Open-source coding agents fill the gap for users who want the agent capability without commercial pricing, or who want to inspect and modify the agent’s behavior, or who want to use coding agents in environments where commercial products aren’t appropriate (air-gapped deployments, regulatory contexts that limit cloud usage, individual developers preferring open tools). The open-source coding agent space has consolidated similar to the commercial space, with a few clear leaders by mid-2026.

How It Works

OpenCode: terminal-first, provider-agnostic open-source coding agent with TUI, desktop and IDE clients (the repository moved from sst/opencode to anomalyco/opencode). With about 220k GitHub stars as of October 2026 it is the most-starred open-source coding agent. The open-source OpenAI Codex CLI (github.com/openai/codex) is the other active terminal option.

Aider: the original Git-native terminal agent. The pattern: run aider in a project, instruct it to make changes, the changes are committed as separate Git commits with descriptive messages. Free to use; real API spend on a busy day with frontier models is $2—8. Still usable, but development has slowed: the last release is v0.86.0 (August 2025). Weakness: no IDE polish; smaller community than Cursor or Claude Code; learning curve for developers not already in the terminal.

Cline: open-source VS Code-based coding agent. The pattern fits developers who want the IDE experience without commercial pricing. Active development community; integrates with multiple foundation model providers. Less polished than Cursor or Windsurf but the gap is narrower than for niche products.

Continue: open-source coding extension with broad IDE support (VS Code, JetBrains), focused on configurable AI-assisted coding with the developer in control. The repository is now read-only and no longer maintained after a final 2.0.0 release, so it is no longer a current recommendation; Cline and its active fork Kilo Code are the open alternatives in the editor.

Choice criteria: OpenCode or Codex CLI for terminal-native workflow; Aider for a Git-commit-per-change workflow; Cline for IDE-based autonomous-ish workflow. The open-source coding agent space is more fragmented than the commercial space; the user is expected to invest in selecting and configuring rather than buying a polished product.

When to Use It

Cost-sensitive deployments where commercial pricing is the limitation. Privacy-sensitive deployments where inspecting the agent’s behavior matters. Customization requirements that commercial products don’t accommodate. Individual developers preferring open tools. Educational and research uses.

Alternatives --- commercial coding agents (prior entries) where commercial polish and product engineering matter. Direct foundation model API integration for the most customization at the cost of building everything yourself.

Sources

opencode.ai, github.com/anomalyco/opencode
cline.bot, aider.chat, github.com/openai/codex

Pattern · 5 of 13

Prompt-to-app builders (Lovable, Bolt.new, v0, Replit)

Pattern page →

Classification Coding agents that turn a conversation into a running, deployed application for people who do not write code.

Source: Lovable (lovable.dev); Bolt.new (bolt.new, StackBlitz); v0 (v0.app, Vercel); Replit Agent (replit.com)

Intent

Let a person describe an application in chat and get back a working, hosted app with frontend, database, authentication and deployment, without opening an editor or reading the code.

Motivating Problem

The coding agents above assume a developer who reviews diffs and owns a repository. A much larger group, founders, product managers, designers and small businesses, wants a working product and cannot review code at all. For them the agent has to own the whole path from prompt to running app: choose the stack, wire the database and auth, and deploy. This group has produced the largest revenue in the coding category: Lovable was reported at roughly $500M ARR with 146 employees in June 2026.

How It Works

Lovable: a conversational full-stack generator from Stockholm (founded 2023, growing out of the open-source GPT Engineer project). It generates a React frontend with a Supabase backend (PostgreSQL, auth, storage) and deploys in one flow, hiding the code by default. Work is billed in credits per change, and the cost per change grows with app size, so long projects get more expensive over time. Projects can be exported to GitHub for engineers to continue.

Bolt.new: from StackBlitz, built on WebContainers, which run Node.js inside the browser tab. It supports several frameworks, including Expo for React Native mobile apps, and routes each task to a model automatically. Fits developers who want a full environment in a browser tab.

v0: from Vercel. Since the February 2026 relaunch, each chat works on its own Git branch with automatic commits and merges by pull request, and apps deploy to Vercel in one click. Fits teams already shipping Next.js on Vercel, since its output arrives as reviewable pull requests.

Replit Agent: builds and hosts the app on Replit’s own runtime (the autonomous-tier entry above covers Agent 4).

Pattern across the products: the agent owns the stack choice and the deployment, which is what makes them usable by non-developers and what makes leaving them hard. Generated code that nobody reviews carries the usual security risks of AI-generated code into production, and the users least able to spot them are the main audience.

When to Use It

Prototypes, internal tools, landing pages and early products where speed to a working demo matters more than long-term maintainability. Non-technical founders validating an idea with real users. Plan the handoff early: export to GitHub and move to a developer-oriented coding agent once the app grows, and get a security review before it handles payments or personal data.

Alternatives: the supervised and autonomous coding agents above once a developer owns the code. Low-code platforms where the app is mostly forms and workflows over existing data. Enterprise agent platforms (Section F) where the goal is an agent rather than an app.

Sources

lovable.dev, bolt.new, v0.app, replit.com
heyuan110.com/posts/ai/2026-07-08-lovable-vs-v0-vs-bolt/ (comparison, July 2026)
en.wikipedia.org/wiki/Lovable_(company)

Section C — Agent frameworks

LangChain/LangGraph, Microsoft Agent Framework, CrewAI, Pydantic AI, Vercel AI SDK: build-your-own substrate

Agent frameworks are the build-your-own substrate for custom agents. Where products in Section B and Section D provide turnkey solutions for specific verticals, frameworks provide primitives for building custom agents that don’t fit existing products. The category has consolidated through 2024—2026, with LangChain/LangGraph as the dominant choice and OpenAI Agents SDK as the established alternative. Microsoft Agent Framework, CrewAI, and Pydantic AI hold positions in specific niches (multi-agent orchestration, lightweight Python typing). The choice among them depends on the team’s preferences and the use case shape. The provider-native SDKs have their own entries elsewhere in the series: for the Claude Agent SDK, see Volume 18, The Claude Agent SDK; for the OpenAI Agents SDK, see Volume 9, OpenAI Agents SDK.

Pattern · 6 of 13

LangChain and LangGraph

Pattern page →

Classification The dominant agent framework as of mid-2026 — broad ecosystem, complex feature surface.

Source: langchain.com (LangChain Inc.; commercial company with open-source roots)

Intent

Provide a comprehensive Python and TypeScript framework for building LLM-powered applications and agents, with LangChain as the broader application framework and LangGraph as the specific orchestration layer for multi-step agent workflows.

Motivating Problem

LangChain emerged as the early framework for LLM-powered applications and dominated through 2023—2024 partly through first-mover advantage and partly through aggressive scope (integrations with virtually every model provider, vector database, tool, and adjacent technology). LangGraph emerged as the orchestration-specific layer, addressing complaints that LangChain itself was too abstract for production agents. The combination is the broadest-adopted agent framework as of mid-2026; the ecosystem (LangSmith for observability and evals, LangSmith Deployment, formerly LangGraph Platform, for hosting agents, and LangSmith Studio for visual debugging) is the largest in the space.

How It Works

LangChain core: integrations with foundation model providers (Anthropic, OpenAI, Google, etc.), vector databases (Pinecone, Weaviate, Chroma, etc.), document loaders, tools, and adjacent infrastructure. The library provides primitives for chaining model calls, retrieving from corpora, calling tools, and managing conversation state. LangChain and LangGraph reached 1.0 in October 2025; since then LangChain’s main entry point is create_agent, built on the LangGraph runtime, with a middleware system for human-in-the-loop, summarization and PII redaction. The older chains moved to the langchain-classic package.

LangGraph: state-machine-based orchestration for agent workflows. Build agents as directed graphs of nodes; each node is a step (model call, tool execution, conditional logic); edges define the flow between steps with conditional branching. The pattern fits multi-step agents with explicit state transitions; the structure makes debugging and observability tractable.

Ecosystem: LangSmith for observability and evaluation (Volumes 4, 7 and 8), LangSmith Deployment for hosting, LangSmith Studio for visualization and debugging. LangServe has been deprecated since November 2024. The ecosystem coupling is significant: teams using LangChain typically use LangSmith for observability because the integration is seamless; switching costs are real.

Trade-offs: LangChain’s breadth is its strength and its weakness. The integrations cover everything; the feature surface is large enough that learning curves are real; the abstraction layers have been criticized as over-engineered for simple use cases. LangGraph addresses the over-abstraction complaint partly but adds its own learning curve. The framework rewards investment in understanding it; it punishes teams that try to use it lightly without engaging with its patterns.

Adoption pattern: dominant in agent framework usage by ecosystem size and developer mindshare. Many teams use LangChain by default unless they have specific reasons not to; the default has held up partly because the ecosystem advantages compound (more integrations than alternatives, more documentation, larger community for support).

When to Use It

Production agent development where ecosystem breadth matters. Multi-model deployments needing integrations with multiple providers. Teams comfortable investing in framework learning curves. Cases where LangSmith’s observability integration adds value. Use cases that match LangGraph’s state-machine orchestration pattern.

Alternatives --- OpenAI Agents SDK (Volume 9) or the Claude Agent SDK (Volume 18) for provider-native development. Pydantic AI for typed-Python with lighter abstractions. Microsoft Agent Framework or CrewAI for multi-agent-specific use cases. Direct foundation model APIs for cases where framework overhead exceeds framework benefit.

Sources

langchain.com
github.com/langchain-ai/langchain
github.com/langchain-ai/langgraph

Pattern · 7 of 13

AutoGen, CrewAI, PydanticAI, Vercel AI SDK — the alternatives

Pattern page →

Classification Agent frameworks with specific positioning vs. the dominant LangChain alternative.

Source: Microsoft Agent Framework and AutoGen (Microsoft); CrewAI (crewai.com); Pydantic AI (pydantic.dev/docs/ai); Vercel AI SDK (ai-sdk.dev)

Intent

Cover the agent frameworks that hold meaningful positions in specific use cases or for specific developer preferences, alongside the dominant LangChain and provider-native options.

Motivating Problem

The agent framework space isn’t a winner-take-all market. Different frameworks fit different use cases and developer preferences. The four covered here have meaningful adoption and offer specific value that the dominant alternatives don’t provide as well.

How It Works

Microsoft Agent Framework and AutoGen: AutoGen was Microsoft’s open-source multi-agent framework, focused on conversation-based multi-agent patterns. In October 2025 Microsoft put AutoGen and Semantic Kernel into maintenance mode (fixes only) and pointed new users to their successor, Microsoft Agent Framework, which reached 1.0 in April 2026. AG2 is a separate community fork of AutoGen. Best for explicit multi-agent use cases, especially on Azure.

CrewAI: opinionated framework for multi-agent orchestration with a role-based abstraction (“agents” have roles, goals, and backstories; “crews” coordinate multiple agents through defined workflows). Open-core with a commercial enterprise tier. Fits teams that want a more opinionated multi-agent abstraction than Microsoft Agent Framework’s flexibility provides.

Pydantic AI: typed-Python agent framework built on Pydantic for validation. Emphasis on type safety, structured outputs, and Python developer experience. Lightweight abstractions compared to LangChain. Fits teams that value Python type system rigor and want less framework overhead than LangChain provides.

Vercel AI SDK: TypeScript-first SDK from Vercel (now at version 6) with first-class support for generative UI (Volume 13 covers), an Agent abstraction, tool-execution approval and MCP support. Strong for web frontend agent development where the AI SDK UI hooks such as useChat are central to the application; the RSC-based useUIState API is experimental and not recommended for production. Less appropriate for backend-heavy Python agent development.

When to Use It

Microsoft Agent Framework for multi-agent systems where conversation-based coordination is the pattern. CrewAI for production multi-agent systems where the role-based abstraction fits. Pydantic AI for typed Python development with lightweight abstractions. Vercel AI SDK for web frontend agent development with generative UI requirements.

Alternatives --- LangChain/LangGraph for broader ecosystem coverage. Provider-native SDKs for single-provider deep integration. Direct APIs for minimal framework overhead.

Sources

github.com/microsoft/agent-framework (github.com/microsoft/autogen for legacy), crewai.com, pydantic.dev/docs/ai, ai-sdk.dev

Section D — Vertical agent products

Customer support, voice, legal, research: verticalized agent solutions for specific domains

Beyond coding, vertical agent products address specific business domains with productized solutions. The verticals vary in maturity. Customer support is the second most mature vertical after coding, with several production-grade products. Voice agents, the phone channel of support and sales, have become a platform category of their own. Sales and marketing tools (11x, Clay, Apollo) are listed in Appendix G. Legal AI is dominated by Harvey for large-firm work. Enterprise research is consolidating around Hebbia, Glean, and Perplexity Enterprise. Healthcare AI is highly fragmented and regulated. The pattern of vertical agents: they encode domain expertise (workflows, terminology, integrations) that general-purpose agents don’t provide, at the cost of being tied to specific domains.

Pattern · 8 of 13

Customer support agents (Decagon, Sierra, Intercom Fin)

Pattern page →

Classification Production-grade AI customer support agents handling deflection, agent assistance, and autonomous resolution.

Source: Decagon (decagon.ai); Sierra (sierra.ai); Fin, formerly Intercom (fin.ai)

Intent

Automate customer support interactions through AI agents that handle inquiries autonomously, assist human agents with information retrieval and response drafting, and integrate with existing customer support infrastructure (Zendesk, Salesforce, custom ticketing).

Motivating Problem

Customer support is high-volume, has well-understood patterns (FAQ-like questions, account inquiries, troubleshooting), and benefits substantially from automation when the automation works well. The vertical has consolidated through 2024—2026 around a handful of production-grade products. Decagon emphasizes autonomous resolution; Sierra emphasizes brand-customized agent experiences; Fin, the AI agent from the company formerly called Intercom, builds on Intercom’s help desk position. Each takes a different go-to-market position; the underlying technology has converged on similar patterns.

How It Works

Decagon: autonomous customer support agents that resolve customer inquiries end-to-end without human agent involvement for cases the agent can handle. Strong on resolution rate metrics; emphasizes the autonomous-resolution value proposition. Fits companies with high inquiry volume where deflection and autonomous resolution are the primary value drivers.

Sierra: AI customer experience platform with emphasis on brand-customized agent experiences. The agent reflects the company’s brand voice and policies; integration with existing customer data and systems is central to the value proposition. Fits companies where customer experience differentiation matters and the agent represents the brand directly to customers.

Fin: Intercom renamed the company to Fin in May 2026, keeping the Intercom name for its help desk. The Fin AI agent runs on any help desk, not only Intercom’s, and is priced per outcome. In June 2026 Salesforce signed an agreement to acquire Fin for about $3.6 billion to extend Agentforce (Section F), with closing expected in Salesforce’s fiscal Q4 2027. Fits companies already on Intercom, and companies that want a support agent priced per resolution on their existing help desk.

Pattern across the products: integration with customer data systems is the primary integration challenge; the agent’s ability to access account information, prior interaction history, and product documentation determines its capability. Voice support is increasingly part of the product offering; the next entry covers the voice platforms. Pricing models vary but typically combine per-resolution fees with platform subscription.

When to Use It

Companies with customer support operations where AI agents can handle a meaningful share of inquiries. Volume-driven support operations where deflection and autonomous resolution improve cost structure. Companies needing to scale support without proportional headcount growth.

Alternatives --- build on agent frameworks (Section C) for companies with specific requirements existing products don’t meet. Use the foundation model providers directly for cases where deeper customization matters. Stay with traditional customer support tools (Zendesk, Salesforce, the Intercom help desk) where AI agent adoption isn’t yet the right move.

Sources

decagon.ai, sierra.ai, fin.ai

Pattern · 9 of 13

Voice agent platforms (ElevenLabs Agents, Vapi, Retell)

Pattern page →

Classification Platforms for building and running agents that hold real-time phone and voice conversations.

Source: ElevenLabs Agents (elevenlabs.io/agents); Vapi (vapi.ai); Retell AI (retellai.com)

Intent

Provide the speech, turn-taking and telephony layer for agents that answer and place phone calls, so a team can configure a voice agent’s prompt, tools and voice instead of building the audio pipeline itself.

Motivating Problem

A large share of customer contact still happens by phone, and voice agents fail in ways chat agents do not. A pause of more than about a second makes the conversation feel broken, callers interrupt, and the agent has to work with phone numbers, IVR menus, transfers to humans and call recording rules. Wiring speech-to-text, a model and text-to-speech to a telephony provider is a project of its own. The customer support products above handle voice as one channel among several; the voice platforms make it the whole product and sell it to teams building their own agents.

How It Works

The common architecture chains three stages per turn: speech-to-text transcribes the caller, a language model decides the reply and any tool calls, and text-to-speech speaks it. The platforms compete on latency (both Vapi and Retell advertise responses around 600ms), on which providers can be plugged into each stage, and on the telephony features around the conversation.

ElevenLabs Agents: built on ElevenLabs’ own voice models. Agents run across voice, chat and email in 90+ languages and connect to Twilio, Genesys, Amazon Connect, Salesforce and Zendesk. Enterprise options include HIPAA compliance, SOC 2 Type II, data residency in the US, EU and India, and a zero-retention mode. Fits teams that want voice quality and a configured agent with little engineering.

Vapi: developer-first platform. An assistant combines a transcriber, a model and a voice chosen from many providers (OpenAI, Anthropic, Google, Deepgram, ElevenLabs and others). Squads chain several specialized assistants with context-preserving transfers between them, and assistants, tools and tests can be kept as files in git and promoted through environments. Fits engineering teams that want control over each stage.

Retell AI: focused on production phone calls. Built-in warm transfer to humans, IVR navigation, batch outbound campaigns, branded caller ID and post-call analysis, with HIPAA, SOC 2 Type II, GDPR and ISO 27001 compliance. Priced per minute of call time (about $0.07 to $0.31 depending on the models and voice chosen).

Pattern across the products: per-minute pricing, provider choice per stage, and a testing problem that text agents do not have, since a voice agent has to be evaluated on recorded or simulated calls under real network latency.

When to Use It

Inbound support lines, appointment booking, lead qualification and outbound reminder calls where the volume justifies automation and the call flows are well defined. Pick ElevenLabs Agents for voice quality and quick setup, Vapi for developer control and provider choice, Retell for telephony-heavy call-center work.

Alternatives: the customer support products above where voice is one channel of a broader support deployment. Contact-center suites (Genesys, Amazon Connect) with their own AI features where the call center already runs on them. Speech-to-speech model APIs from the foundation model providers for teams building the pipeline themselves.

Sources

elevenlabs.io/agents, vapi.ai, docs.vapi.ai/quickstart/introduction, retellai.com

Pattern · 10 of 13

Legal, research, and other vertical agents (Harvey, Hebbia, Glean, Perplexity)

Pattern page →

Classification Vertical agents for legal work, enterprise research, and knowledge synthesis.

Source: Harvey (harvey.ai); Hebbia (hebbia.com); Glean (glean.com); Perplexity Enterprise (perplexity.ai)

Intent

Cover three additional vertical categories with established players: legal AI dominated by Harvey for large-firm work, enterprise research dominated by Hebbia and Glean for internal knowledge synthesis, and Perplexity for consumer and enterprise research with web-search emphasis.

Motivating Problem

Legal AI, enterprise research, and consumer/enterprise web research are three additional verticals with established product leaders as of 2026. Each addresses a specific category of work --- legal practice for Harvey, internal knowledge for Hebbia and Glean, web-based research for Perplexity --- with vertical-specific integrations and capabilities general-purpose agents don’t provide.

How It Works

Harvey: AI agent for legal work, dominated in the top-100 law firm market. Handles document review, contract analysis, research synthesis, drafting assistance. Integrated with legal-specific data sources and workflows. Pricing reflects the high-value-add positioning in legal services. Competition exists in specific niches (EvenUp for personal injury, others for specific practice areas) but Harvey has the strongest position in big-law adoption.

Hebbia: enterprise research and knowledge synthesis agent. Strong in financial services, consulting, and other knowledge-work-intensive industries. The product handles document collections, structured data, and synthesis tasks that human analysts would otherwise spend significant time on.

Glean: enterprise search and knowledge agent integrated with corporate data sources (Slack, Notion, Google Workspace, Microsoft 365, custom systems). Less analyst-focused than Hebbia, more focused on knowledge retrieval and synthesis across the company’s existing knowledge stores. Strong adoption in mid-market and enterprise companies.

Perplexity (Pro and Max consumer plans, Enterprise Pro, and the Comet browser): AI-powered web research with citations as a first-class UX element. Its most visible agent product since late 2025 is Comet, an agentic browser that has been free since October 2025 and has an enterprise version; Perplexity Enterprise extends the pattern to enterprise data sources with appropriate security and access controls. The product competes with traditional search engines and with AI assistants on different fronts.

Pattern across the products: vertical integration matters. Each product invests substantially in the integrations and domain expertise that general-purpose agents would have to replicate to compete. The vertical positioning creates defensive moats; the trade-off is each product covers one specific domain rather than being general-purpose.

When to Use It

Harvey for large law firm legal work. Hebbia for analyst-driven research workflows. Glean for enterprise knowledge retrieval across existing corporate data. Perplexity Pro for individual web research; Perplexity Enterprise for company-wide web research with corporate data integration. Each fits its specific vertical; using them for adjacent verticals usually produces worse fit than the vertical-specific alternative.

Alternatives --- build on agent frameworks (Section C) for companies with specific requirements existing products don’t meet. Use consumer AI assistants (Appendix G) where vertical depth isn’t needed.

Sources

harvey.ai, hebbia.com, glean.com, perplexity.ai, perplexity.ai/comet

Section E — Computer use and browser agents

Anthropic computer use, OpenAI’s ChatGPT agent, Browserbase: agents that operate computers and browsers

Computer use and browser automation represent the highest-blast-radius agent capability and a category still maturing through 2025—2026. Anthropic’s computer use tool and Claude in Chrome, OpenAI’s ChatGPT agent mode and computer-use tool, and Google’s Gemini computer-use model are the foundation-model-provider-native products; Perplexity’s Comet is the main independent agentic browser. Browserbase provides infrastructure for browser-based agents from third parties. The category is in the emerging-to-maturing transition: production deployments exist but the patterns are still being figured out, and significant product evolution is expected through 2027.

Pattern · 11 of 13

Anthropic Computer Use, OpenAI Operator, and Browserbase

Pattern page →

Classification Agents that operate computers and browsers — the highest-blast-radius agent capability.

Source: Anthropic computer use tool and Claude in Chrome; OpenAI ChatGPT agent and computer-use tool; Browserbase (browserbase.com); related computer-use offerings

Intent

Enable AI agents to operate computers (clicking, typing, scrolling, navigating, executing tasks in arbitrary applications) and browsers (visiting URLs, filling forms, extracting data, interacting with web applications), with appropriate sandboxing and human oversight.

Motivating Problem

Many useful tasks happen outside the structured API surface that traditional agent tool calling addresses. Booking appointments through websites that don’t expose APIs. Operating SaaS applications without programmatic access. Filling government forms. Researching across websites without structured data access. Computer use and browser automation address this gap by giving agents the ability to interact with software the way humans do --- through the visual interface. The blast radius is significant (the agent has approximately the capability of a human at a keyboard); sandboxing infrastructure (Volume 12 Section D) is essential.

How It Works

Anthropic Computer Use: API and tooling for desktop automation. The agent receives screenshots, issues keyboard and mouse events, observes the result. The pattern is most useful for tasks requiring interaction with desktop applications or complex web workflows. The tool is implemented on the client side: the developer supplies the sandboxed environment, and Anthropic provides a reference container to start from. Claude in Chrome is Anthropic’s end-user browser agent. The capability has matured through 2024—2026 with significant improvements in accuracy and latency.

OpenAI: computer use is now part of ChatGPT (agent mode and the desktop app) and Codex, and is available to developers as the computer-use tool in the Responses API. The standalone Operator product (January to August 2025) and the Atlas browser (October 2025 to August 2026) were retired and their features folded into ChatGPT and Codex. The competitive positioning vs. Anthropic’s tool depends on the specific task; both have strengths in different domains.

Browserbase: infrastructure for browser-based agents. Provides headless browser environments via Chrome DevTools Protocol, with isolation, session management, and observability suitable for production agent deployments. Used by many third-party agent products (research agents, automation tools, custom agents) that need browser capability without building their own infrastructure.

Anchor Browser and similar alternatives compete with Browserbase on specific dimensions (pricing, regional availability, feature mix). The category is small enough that the competition is among a handful of credible providers.

Production patterns: most production computer-use deployments use sandboxed cloud environments rather than letting agents touch the user’s actual machine. The sandbox isolation matters because the blast radius of computer use is significant; the cloud-hosted pattern bounds the risk while making the capability available. HITL gates (Volume 7) for sensitive actions are essential. Volume 3, computer use, covers the tool interface, and Volume 12, Browser automation sandboxes (Browserbase, Anthropic Computer Use, Anchor Browser), covers isolating these sessions.

When to Use It

Tasks requiring interaction with software that doesn’t expose programmatic APIs. Workflows spanning multiple applications where the alternative is custom integration work. Research and data collection tasks across websites. Use cases where the agent’s value comes from its ability to do what a human at a keyboard would do, faster or in parallel.

Alternatives --- API-based integration where APIs exist (almost always preferable when available). Robotic Process Automation (RPA) tools for structured workflows (less flexible than AI computer use but more predictable). Custom screen scraping for specific narrow tasks (more fragile than full computer use but more efficient when the task is well-defined).

Sources

platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool
developers.openai.com/api/docs/guides/tools-computer-use
browserbase.com

Section F — Enterprise agent platforms

Salesforce, Microsoft, Google, OpenAI: governed suites for building and running agents across a company

By 2026 the largest enterprise agent purchases are platforms from incumbent suite vendors and model providers that let business teams build agents on company data, connect them to existing systems, and govern them centrally. The suite vendors start from the systems of record they already sell (CRM, productivity, cloud); the model providers start from the model and add the governance layer. The category is consolidating through acquisitions: Salesforce’s agreement to buy Fin (Section D) folds a leading support agent into Agentforce. Infrastructure for running agents (Volume 5, AWS Bedrock AgentCore) sits one layer below these suites.

Pattern · 12 of 13

Enterprise agent platforms (Salesforce Agentforce, Microsoft Copilot Studio, Google Gemini Enterprise, OpenAI Frontier)

Pattern page →

Classification Governed build-and-run platforms for company-wide agents from suite vendors and model providers.

Source: Salesforce Agentforce (salesforce.com/agentforce); Microsoft Copilot Studio; Google Gemini Enterprise (cloud.google.com/gemini-enterprise); OpenAI Frontier

Intent

Give an enterprise one governed place to build, connect, deploy and monitor many agents on its own data and systems, so business teams can create agents without each one becoming a separate engineering project with its own permissions and audit trail.

Motivating Problem

Once a company has more than a handful of agents, the hard problems stop being the model or the prompt. Each agent needs access to CRM, ticketing, documents and data warehouses under the right user’s permissions; IT needs to know which agents exist, what they can touch and who approved them; and changes need a release process. Building that layer per agent on a framework repeats the same work many times. The suite vendors already hold the data and identity, and the model providers want the enterprise relationship, so both now sell the layer as a product.

How It Works

Salesforce Agentforce: agents built inside the Salesforce platform. Agent Builder configures agents, subagents, actions and instructions; Agent Script gives builders finer control over agent behaviour; actions reuse existing Flows and prompts grounded in Salesforce data. Salesforce reported Agentforce at $1.2 billion ARR in Q1 of fiscal 2027, and in June 2026 agreed to acquire Fin for about $3.6 billion to add a packaged support agent.

Microsoft Copilot Studio: a platform for creating and managing custom agents, workflows and apps with no code, part of the Power Platform. Agents connect through 1,500+ prebuilt data connectors and MCP servers, can run autonomously on business processes, and publish internally, to websites or to social channels. Application lifecycle management covers dev, test and production environments with version control, release pipelines and approval gates.

Google Gemini Enterprise (formerly Agentspace): Google’s platform to discover, create, run and manage agents for business users. It connects to 100+ sources, including Google Workspace, Microsoft 365, Slack, Jira, Salesforce and ServiceNow, with access following each user’s existing permissions, and routes work across models under one set of permissions and one bill.

OpenAI Frontier: launched in February 2026 to a limited set of customers, with HP, Intuit, Oracle, State Farm, Thermo Fisher and Uber among the first. OpenAI presents agents as coworkers that each get an identity, permissions and guardrails. A shared semantic layer connects data warehouses, CRM, ticketing and internal applications; agents run locally, in enterprise clouds or on OpenAI-hosted runtimes; and the platform can manage third-party agents as well as OpenAI’s, with built-in evaluation.

Trade-offs: the suites make governance and data access easy inside their own ecosystem and harder outside it. Agentforce fits companies whose processes live in Salesforce, Copilot Studio companies on Microsoft 365 and Power Platform, Gemini Enterprise companies on Google Workspace or Google Cloud. Frontier is the least tied to a system of record but the newest and least widely available.

When to Use It

Organizations deploying many agents across departments where central governance, permissions and audit matter more than per-agent customization. Business teams that need to build agents without engineering support. Companies already committed to one of the suites, where the platform reuses existing identity, data and procurement.

Alternatives: agent frameworks (Section C) for custom agents the suites cannot express. Vertical products (Section D) where one domain dominates. Cloud agent infrastructure (Volume 5) for engineering teams that want to run their own agents with managed runtime, identity and memory but without a suite.

Sources

salesforce.com/agentforce
microsoft.com/en-us/microsoft-copilot/microsoft-copilot-studio
cloud.google.com/gemini-enterprise
axios.com/2026/02/05/openai-platform-ai-agents (OpenAI Frontier launch)
martech.org/salesforce-acquires-fin-formerly-known-as-intercom/

Section G — Agent observability and ops platforms

LangSmith, Phoenix, Langfuse, Helicone, Braintrust, Galileo --- production agent operations

Agent observability platforms instrument production agent deployments: trace records of agent behavior, evaluation pipelines for testing, prompt management, cost tracking, debugging tools. The category has grown rapidly through 2024—2026 as agent products moved from prototypes to production and teams needed the operational visibility that traditional application monitoring doesn’t provide for AI-specific concerns. The leaders divide into open-source-first options (Phoenix, Langfuse), commercial-focused options (LangSmith for LangChain ecosystem; Braintrust and Galileo for broader markets), and enterprise-governance-emphasis options. Ownership moved quickly in 2026: ClickHouse bought Langfuse, Cisco bought Galileo, and Mintlify bought Helicone. This section is a buyer’s comparison; the structural entries live in other volumes (Volume 7, Arize Phoenix, LangSmith and Langfuse; Volume 8, LangSmith Evaluators; Volume 4, AgentOps).

Pattern · 13 of 13

Agent observability platforms (LangSmith, Phoenix, Langfuse, Helicone, Braintrust, Galileo)

Pattern page →

Classification Observability, evaluation, and operations platforms for production agent deployments.

Source: LangSmith (langchain.com); Phoenix (arize.com/phoenix); Langfuse (langfuse.com); Helicone (helicone.ai); Braintrust (braintrust.dev); Galileo (galileo.ai)

Intent

Provide the operational substrate for production agents: tracing of agent behavior, evaluation pipelines, prompt management, cost tracking, performance monitoring, and the operational tooling that distinguishes production deployments from prototypes.

Motivating Problem

Agent deployments differ from traditional software deployments in operational requirements: the behavior is stochastic and needs evaluation rather than just monitoring; the costs are usage-based with substantial variability; the failure modes are AI-specific (hallucinations, prompt injection, tool errors, refusals); the debugging requires tracing through multi-step reasoning. Traditional application performance management tools don’t address these requirements well. Agent observability platforms emerged to fill the gap, with significant maturation through 2024—2026.

How It Works

LangSmith: LangChain’s commercial observability platform. Tight integration with LangChain and LangGraph (automatic tracing of agent runs with minimal instrumentation). Evaluation pipelines, prompt management, dataset management for testing. The default observability choice for teams using LangChain; substantial market share by ecosystem coupling.

Phoenix: Arize’s open-source observability platform. Framework-agnostic (works with LangChain, OpenAI SDK, Anthropic SDK, custom code). Strong on trace visualization and span-level debugging. Open-source nature appeals to teams that want to inspect and modify their observability infrastructure. Arize sells the commercial cloud and enterprise tier.

Langfuse (part of ClickHouse since January 2026): open-source observability, evals and prompt management; self-hosted or cloud, and Langfuse says it stays open source after the acquisition. Framework-agnostic. Competes with LangSmith and Phoenix; takes positions that don’t require commitment to LangChain.

Helicone: open-source LLM gateway and observability proxy that sits between agents and foundation model APIs, providing visibility, caching, and cost optimization. Mintlify acquired it in March 2026 and put it in maintenance mode (security fixes and new model support only); as of October 2026 the homepage says Helicone is no longer part of Mintlify, so its future is unsettled. LiteLLM or Portkey are the alternatives for gateway-plus-cost use cases.

Braintrust: emphasis on evaluation and prompt management. The product distinguishes itself on the eval-and-improvement-loop dimension rather than pure observability. Commercial-focused with strong enterprise traction.

Galileo (part of Cisco since May 2026, folded into Splunk Observability): enterprise evaluation and agent monitoring with a governance emphasis. Targets large enterprise deployments with compliance and risk management requirements alongside the observability features. Positioning emphasizes the governance dimensions that regulated industries care about.

Choice criteria: LangSmith for LangChain-ecosystem deployments. Phoenix or Langfuse for framework-agnostic open-source-friendly deployments. A gateway (LiteLLM, Portkey, or Helicone once its ownership settles) where cost optimization is a primary concern. Braintrust where evaluation discipline matters most. Galileo for enterprise with governance requirements. Multiple products coexist in many deployments where different teams have different preferences.

When to Use It

Production agent deployments where operational visibility matters. Teams scaling beyond prototype where debugging requires structured tracing. Regulated environments requiring auditable records of agent behavior (overlaps with Volume 11 and Volume 12 requirements). Cost-sensitive deployments where understanding usage patterns affects financial planning.

Alternatives --- vendor-native observability (OpenAI dashboard, Anthropic dashboard) for simple deployments. Traditional application monitoring (Datadog, New Relic) extended with AI-specific instrumentation for organizations with strong existing APM investments. Custom observability for cases where the commercial platforms don’t fit the deployment patterns.

Sources

langchain.com/langsmith/observability, arize.com/phoenix, langfuse.com, langfuse.com/blog/joining-clickhouse
helicone.ai, mintlify.com/blog/mintlify-acquires-helicone, braintrust.dev, galileo.ai, blogs.cisco.com/news/cisco-announces-the-intent-to-acquire-galileo

Appendix A --- Category Density and Consolidation Reference

Cross-reference of agent product categories with density level, state of consolidation, and current leaders or examples. Snapshot as of late 2026.

Category	Density	State of consolidation	Leaders / examples
Foundation models	Crowded	6+ major providers	Anthropic, OpenAI, Google, Meta, DeepSeek, Qwen, xAI
Agent frameworks	Maturing	LangChain dominant	LangChain/LangGraph, OpenAI Agents SDK, MS Agent Framework, CrewAI
Coding agents	Crowded→Maturing	8 production-grade winners	Claude Code, Cursor, Devin, Copilot, Codex, Replit, OpenCode
Prompt-to-app builders	Crowded	Lovable leading by revenue	Lovable, Bolt.new, v0, Replit
Customer support agents	Crowded	Several leaders	Decagon, Sierra, Fin (being acquired by Salesforce)
Voice agent platforms	Crowded	Several credible options	ElevenLabs Agents, Vapi, Retell
Sales/marketing agents	Maturing	11x emerging	11x, Clay, Apollo AI
Legal AI	Maturing	Harvey dominant in big-law	Harvey, EvenUp (vertical niches)
Enterprise research	Maturing	Glean and Hebbia leading	Glean, Hebbia, Perplexity Enterprise
Computer use	Emerging	Foundation providers lead	Anthropic computer use, ChatGPT agent, Comet, Browserbase
Enterprise agent suites	Maturing	Suite vendors lead	Agentforce, Copilot Studio, Gemini Enterprise, OpenAI Frontier
Consumer AI assistants	Crowded	ChatGPT dominant by users	ChatGPT, Claude.ai, Gemini, Perplexity, Grok
Agent observability	Crowded	Acquisitions under way L	angSmith, Phoenix, Langfuse, Braintrust, Galileo

Appendix B --- The Series

This catalog joined the thirteen prior volumes to form a fourteen-layer vocabulary for agentic AI (the series has since grown to nineteen volumes), with the explicit caveat that this volume is structurally different from the prior thirteen.

Volume 1 --- Patterns of AI Agent Workflows --- the timing of agent runs.
Volume 2 --- The Claude Skills Catalog --- model instructions in packaged form.
Volume 3 --- The AI Agent Tools Catalog --- the function-calling primitives.
Volume 4 --- The AI Agent Events & Triggers Catalog --- the activation layer.
Volume 5 --- The AI Agent Fabric Catalog --- the infrastructure substrate.
Volume 6 --- The AI Agent Memory Catalog --- the state and context layer.
Volume 7 --- The Human-in-the-Loop Catalog --- HITL engineering.
Volume 8 --- The Evaluation & Guardrails Catalog --- LLM-internal safety mechanisms.
Volume 9 --- The Multi-Agent Coordination Catalog --- the agent-to-agent communication layer.
Volume 10 --- The Retrieval & Knowledge Engineering Catalog --- finding the right information.
Volume 11 --- The AI Compliance & Regulatory Catalog --- compliance-facing governance.
Volume 12 --- The AI Infrastructure Security Catalog --- security around the AI system.
Volume 13 --- The Agent UX Patterns Catalog --- design discipline for agent interaction.
Volume 14 --- The AI Agent Products Survey (this volume) --- a snapshot, not structural vocabulary.

The fourteenth volume is different in kind from the prior thirteen. Volumes 1—13 document structural vocabulary designed to outlast specific products: patterns, mechanisms, and disciplines that hold up across product churn. Volume 14 documents the specific products themselves, with the explicit understanding that the snapshot ages quickly. The prior thirteen volumes will continue to read as useful structural references in 2027 and beyond; this volume will need revision within 18 months to remain accurate.

Why include a structurally-different volume in a series whose value proposition has been structural vocabulary? Because architects need product knowledge alongside structural understanding, and consolidating that product knowledge in one snapshot is more useful than scattering it across the structural volumes. The compromise is honest framing (this volume is a snapshot, not durable vocabulary) and disciplined scope (focus on the substrate-defining products rather than comprehensive coverage). Treat this volume as the perishable layer of the reference; the prior thirteen are the durable layer that should refresh less often.

Appendix C --- What This Snapshot Will Probably Get Wrong

This volume’s explicit honesty requires explicit prediction about what the snapshot will probably get wrong as the months pass. Several categories of expected error:

Specific product names. Some products in this volume will be acquired, renamed, or deprecated within 12 months. The Windsurf saga (Chapter 1) demonstrates how quickly names can change. The structural positions (“IDE-anchored coding agent,” “autonomous async coding agent”) will hold up better than the specific product names occupying those positions.
Market position claims. Where this volume cites a leader (“Harvey dominates legal AI for big-law work”, “LangChain dominates agent frameworks”), the leader claim is current but contingent. Competitors emerge; incumbents stumble; the leadership rankings shift on shorter timescales than the structural vocabulary in Volumes 1—13 evolves.
Pricing references. Where this volume cites pricing (“Cursor’s credit-based billing”, “Devin’s pricing reduction from $500/month”), the specific prices will change. The pricing is informative of the strategic positioning at the moment of writing; the strategic positioning may shift, and the prices certainly will.
Provider product lines. Specific products listed for each foundation model provider (Claude Code, Computer Use, MCP for Anthropic; ChatGPT, GPTs, Codex, Frontier for OpenAI; etc.) reflect mid-2026 product portfolios. Providers add and retire products continuously; the lists are snapshots, not commitments to maintained product lines.
Category consolidation predictions. Where this volume predicts consolidation (“Coding agents will consolidate further within 12 months”), the predictions are educated guesses. Actual consolidation may proceed faster, slower, or in different directions than expected. The signal that consolidation is happening is more reliable than predictions about specific consolidation outcomes.
Open-source vs. commercial trajectories. The current open-vs-commercial mix in each category may shift as the economic models for AI products evolve. Open-source projects may commercialize; commercial products may open-source defensively; the balance may shift differently in different categories.
Acquisitions and corporate moves. Major acquisitions (the Windsurf saga, future deals) will reshape the landscape in ways snapshots can’t anticipate. The list of independent companies as of mid-2026 will not match the list 18 months later.
Emerging categories not yet visible. The current sparse categories (scientific research agents, hardware control agents, embedded agents) may produce credible products that didn’t exist when this volume was written. New product categories may emerge that aren’t covered at all in this volume.

Appendix D --- Discovery and Standards

Resources for tracking the agent product landscape:

Industry analysts: Gartner Magic Quadrants, Forrester Waves for relevant categories; specialist reports from a16z, Menlo Ventures and Artificial Analysis.
AI-focused newsletters: Stratechery, Ben’s Bites, AI Tidbits, Latent Space, The Batch (deeplearning.ai), ChinaTalk.
Tech press: TechCrunch, The Information, Bloomberg, Reuters, Wall Street Journal.
Vendor blogs: anthropic.com/news, openai.com/blog, blog.google/technology/ai, ai.meta.com/blog.
Conference proceedings: Anthropic Code with Claude, OpenAI DevDay, Google I/O and Google Cloud Next, NeurIPS for academic-to-industry transitions.
Product Hunt and similar discovery platforms for emerging products.
Tracking communities: AI Twitter/X, AI subreddits, vendor-specific Discord communities.

Two practical recommendations. First, invest in tracking infrastructure rather than relying on snapshots. The product landscape changes faster than any reference document can keep up; the tracking discipline is what keeps procurement decisions current. Second, distinguish the durable layer (Volumes 1—13 structural vocabulary) from the perishable layer (this volume’s product specifics). The durable layer refreshes slowly; the perishable layer needs continuous refresh.

Appendix E --- Omissions

This catalog covers 13 product clusters across 7 sections. The wider product landscape is significantly larger; a non-exhaustive list of what isn’t here:

Specific products in narrow niches with smaller market presence. Many credible products exist that aren’t covered because their market presence doesn’t justify the space.
Game and entertainment AI products. The category has significant activity (Inworld, character-focused products, AI gaming companions) that doesn’t fit this volume’s enterprise-architect-oriented scope.
Healthcare AI products in depth. Healthcare AI is significant but highly regulated and fragmented; comprehensive coverage requires industry-specific treatment.
Financial services AI products in depth. Similar to healthcare --- significant activity, regulated environment, deserves specialized treatment.
Government and defense AI products. Significant activity in regulated environments not covered here.
Specific products from Chinese, European, Indian, or other regional markets where US-centric tracking is incomplete. The product landscape varies by region; this snapshot is US-centric in its emphasis.
Embedded and hardware-integrated AI products. AI assistants in cars, appliances, and other hardware are growing categories not covered.
Detailed feature comparisons within categories. The volume covers strategic positioning rather than feature matrices that would age even faster than the rest of the content.

Appendix F --- The Series at Fourteen Volumes

This is the fourteenth volume in a series that began as one volume on agent workflow patterns and grew to cover thirteen structural dimensions plus this one product survey. The series has been declared complete several times in earlier volumes’ closing sections; each declaration was honest at the time and wrong in retrospect. The pattern reflects how the field evolved through 2023—2026: each successive volume revealed adjacent areas worth treatment that the prior volumes hadn’t anticipated. The compounding pattern eventually slows as the field matures; whether it has slowed enough at fourteen volumes to declare completion with confidence is a question this final appendix cannot fully answer.

What this volume’s inclusion suggests is that the catalog’s structural ambition has limits. The first thirteen volumes documented patterns, mechanisms, and disciplines designed to outlast products. This volume documents the products themselves, with the explicit acknowledgment that it ages faster than its peers. Including it required relaxing the structural-vocabulary principle that anchored the prior volumes. The relaxation is honest --- architects need product knowledge alongside structural understanding --- but it represents a shift in what the catalog series claims to offer.

Two ways to read the first fourteen volumes together. As a layered reference: Volumes 1—10 cover the engineering substrate of agentic AI; Volumes 11—13 cover the complementary disciplines (compliance, security, design); Volume 14 covers the product landscape that implements the engineering and serves the disciplines. The layers compose: an architect reading the full series gets engineering vocabulary, complementary discipline vocabulary, and product-specific knowledge, with the explicit understanding that the first ten are most durable, the next three age moderately, and the fourteenth ages fastest. As a snapshot of the field at a moment: the fourteen volumes capture the working state of agentic AI engineering and governance in May 2026, with the structural vocabulary positioned to hold up better than the specific products.

Whether to extend the series further is a judgment about diminishing returns. Adjacent areas where comparable treatment would be valuable include: cost engineering for AI systems (the operational discipline of managing inference costs at scale); model lifecycle management beyond evaluation (versioning, deprecation, replacement, migration patterns); enterprise integration patterns between AI systems and existing enterprise systems (ERP, CRM, identity, communication infrastructure). Each could be a volume; none is currently a major gap; each would extend the catalog’s scope incrementally. The cost is the maintenance burden compounds; the catalog’s usability as a coherent reference for any single architect erodes as it grows.

Fourteen volumes at the time of writing (the series has since grown to nineteen). Patterns, Skills, Tools, Events, Fabric, Memory, Human-in-the-Loop, Evaluation & Guardrails, Multi-Agent Coordination, Retrieval & Knowledge Engineering, AI Compliance & Regulatory, AI Infrastructure Security, Agent UX Patterns, and now the AI Agent Products Survey. The structural vocabulary in Volumes 1—13 should hold up better than the specific products in Volume 14. That’s the catalog’s value proposition, applied honestly to a fourteenth volume that violates the proposition deliberately for the architect who needs product knowledge alongside structural understanding. Fourteen volumes in, with this self-aware caveat, the proposition still holds.

Appendix G --- Further Reading

Product groups that earlier drafts of this volume covered as entries. They are listed here as references because they are product listings rather than reusable patterns, or because the consumer products sit outside an engineering catalog.

Foundation model providers (check the model pages; lineups change every few months):

Anthropic Claude - Fable, Opus, Sonnet and Haiku tiers - platform.claude.com/docs/en/models/overview
OpenAI GPT - the GPT-5.x line, with reasoning built into the models rather than a separate o-series - developers.openai.com/api/docs/models
Google Gemini - the Gemini 3.x family - ai.google.dev/gemini-api/docs/models
Meta - closed Muse models (Muse Spark, April 2026) in Meta AI; Llama 4 open weights - ai.meta.com
DeepSeek - open-weight models (DeepSeek V4, April 2026) - api-docs.deepseek.com
Qwen (Alibaba) - open-weight model family - qwen.ai
xAI Grok - xAI is part of SpaceX since February 2026 - docs.x.ai/developers/models

Consumer AI assistants:

ChatGPT - OpenAI’s assistant, about 900 million weekly active users in early 2026; Business (formerly Team) and Enterprise plans - chatgpt.com
Claude.ai - Anthropic’s assistant; Pro and Max plans, Team and Enterprise for organizations - claude.ai
Gemini - Google’s assistant, integrated with Google Workspace - gemini.google.com
Meta AI - assistant built into WhatsApp, Instagram and Facebook, running Muse Spark - meta.ai
Perplexity - citation-first research assistant and the Comet browser (see Section D) - perplexity.ai
Grok - xAI’s assistant, integrated with X - grok.com

Sales and marketing agents:

11x - AI SDR agents; 2025 reporting by TechCrunch questioned its revenue and customer claims, which 11x partly disputes - 11x.ai
Clay - data enrichment and prospecting workflow platform for human-run sales teams - clay.com
Apollo - incumbent sales platform with added AI features - apollo.io

Tracking the landscape (Appendix D lists the categories):

Stratechery - subscription analysis by Ben Thompson - stratechery.com
Latent Space - AI engineering podcast and newsletter - latent.space
The Batch - deeplearning.ai newsletter - deeplearning.ai/the-batch
Artificial Analysis - independent model and provider benchmarks - artificialanalysis.ai
Code with Claude - Anthropic’s developer conference - claude.com/code-with-claude

--- End of The AI Agent Products Survey v0.1 ---