The AI Agent Products Survey

A Snapshot of the Agentic AI Product Landscape, May 2026

Draft v0.1

May 2026

Table of Contents

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:

• Foundation models and provider-native agent offerings: Anthropic Claude, OpenAI GPT, Google Gemini, Meta Llama, DeepSeek, xAI Grok.

• Coding agents: Claude Code, Cursor, Windsurf, Devin, GitHub Copilot, OpenAI Codex, Replit Agent, Aider, open-source alternatives.

• Agent frameworks: LangChain/LangGraph, OpenAI Agents SDK, Anthropic Agent SDK, Vercel AI SDK, AutoGen, CrewAI, PydanticAI.

• Vertical agent products: customer support (Decagon, Sierra, Intercom Fin), sales (11x, Clay), legal (Harvey), research (Hebbia, Glean, Perplexity Enterprise).

• Computer use and browser agents: Anthropic Computer Use, OpenAI Operator, Browserbase.

• Consumer AI assistants: ChatGPT, Claude.ai, Gemini, Perplexity, Grok.

• 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.

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.

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 dominant providers as of mid-2026: Anthropic with the Claude family (Claude Opus 4.7 is the most advanced model currently available; Claude Sonnet 4.6 and Haiku 4.5 are the alternatives); OpenAI with the GPT family (GPT-5.x variants are the production line as of 2026); Google with Gemini (Gemini 2.5 and successors); Meta with Llama (open weights, broadly adopted by frameworks); DeepSeek with its model family; xAI with Grok. 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; Meta provides the open-weight option many frameworks default to. 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 (formerly Swarm, repositioned and shipped as a stable SDK) is the OpenAI-native alternative. Anthropic’s Agent SDK (released through 2025 and 2026) is the Anthropic-native alternative. Vercel AI SDK is the web-developer-oriented option with first-class generative UI primitives (Volume 13 covers these). AutoGen (Microsoft) and CrewAI compete in the multi-agent orchestration space. PydanticAI 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), Windsurf (Cognition, after the Codeium-to-Windsurf rebrand and the 2025 acquisition), Devin (Cognition’s autonomous async option), GitHub Copilot (Microsoft’s enterprise default). OpenAI Codex (the GPT-5.x-powered cloud coding agent), Replit Agent 3 (full-stack scaffolding), and Aider (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, Intercom Fin, 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 observability with a managed cloud option) compete for framework-agnostic observability. Helicone, Braintrust, and Galileo offer additional commercial options with different specific emphases (Helicone on cost and caching, Braintrust on evaluation and prompt management, Galileo on enterprise governance). The category is consolidating; 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, Intercom 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 Anthropic’s 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 source dominates in agent frameworks. LangChain and LangGraph are MIT-licensed; AutoGen is Microsoft’s open-source multi-agent framework; CrewAI is open-core; PydanticAI 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. Aider (terminal coding agent), Cline (open VS Code coding agent), Continue (open-source coding extension) 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, Windsurf, Devin, GitHub Copilot) are commercial. Vertical agents (Decagon, Sierra, Harvey, Hebbia) are commercial. Enterprise observability and management (LangSmith, Helicone Pro, 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 Anthropic’s Agent SDK are open 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).

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; AutoGen and CrewAI hold niche positions. 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

Eight sections survey the agent product landscape as of mid-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 --- Foundation models and 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 --- Consumer AI assistants

• Section G --- Agent observability and ops platforms

• Section H --- Discovery and tracking

Section A — Foundation models and provider agent offerings

Anthropic, OpenAI, Google, Meta, DeepSeek, xAI --- the substrate and their agent products

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 mid-2026 are Anthropic, OpenAI, Google, Meta (with Llama as the dominant open-weight family), DeepSeek (with its competitive cost/performance ratio), and xAI (with Grok). Each provider has its own product positioning, pricing structure, model release cadence, and ecosystem of agent offerings built on top.

The providers also ship their own agent products on top of their foundation models. Anthropic ships Claude Code, Claude in Chrome, Computer Use, the Skills system, and MCP. OpenAI ships ChatGPT, GPTs, Codex, Operator. Google ships Gemini, Gemini Code Assist, Project Astra integrations, 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.

Foundation model providers

Source: Anthropic, OpenAI, Google, Meta, DeepSeek, xAI --- the six dominant foundation model providers in mid-2026

Classification The model substrate underlying all agent products.

Intent

Provide the foundation models on which all agent products and frameworks depend, with characteristic positioning, capabilities, pricing, and deployment options.

Motivating Problem

Every agent depends on at least one foundation model. The provider choice shapes the agent’s capabilities (different models have different strengths and weaknesses), cost profile (foundation model API costs are typically the dominant operational cost for agent deployments), latency profile (different providers have different infrastructure characteristics), and deployment flexibility (some providers offer on-premises deployment; others are cloud-only). Understanding the provider landscape is foundational to every other decision in agent product selection.

How It Works

Anthropic Claude family: Claude Opus 4.7 is the most advanced model currently available, with Claude Sonnet 4.6 as the mid-tier and Claude Haiku 4.5 as the fast/cheap tier. Anthropic emphasizes safety training, reasoning capability, and tool use. The API is the canonical Messages API with extensive support for streaming, tool use, citations, and extended thinking. Anthropic also ships agent-oriented products on top (Claude Code, Computer Use, MCP) that benefit from deeper integration with the underlying model.

OpenAI GPT family: GPT-5.x variants dominate the production line as of 2026, with reasoning models (the o-series) for specific use cases. OpenAI emphasizes broad capability and tool ecosystem; the Chat Completions API and the newer Responses API are the canonical interfaces. OpenAI Agents SDK provides the agent framework on top. The Microsoft partnership shapes OpenAI’s product distribution heavily (Azure OpenAI Service, GitHub Copilot integration, Microsoft 365 Copilot).

Google Gemini: Gemini 2.5 and successors compete on multimodality and integration with Google’s ecosystem. The Gemini Code Assist coding agent and Gemini for Workspace product line reflect Google’s focus on integration with productivity software. Google’s ecosystem advantages (Cloud, Workspace, Android, Chrome) shape its agent product distribution; the model performance is competitive but Google’s position rests heavily on distribution.

Meta Llama: open-weight models that have become the default substrate for many open-source agent frameworks. Llama 4 and successors continue the pattern of releasing competitive models with open weights, enabling self-hosted deployment, fine-tuning, and integration with infrastructure where API dependency on cloud providers isn’t acceptable. Meta’s own agent product positioning is less visible than its model release strategy.

DeepSeek: Chinese-origin foundation models competitive on cost and increasingly on capability. The DeepSeek family of models has gained substantial adoption in cost-sensitive use cases and as a competitive alternative to the major American providers. The China-based origin creates supply chain and regulatory considerations for some enterprise deployments.

xAI Grok: integrated tightly with the X platform and pursuing a positioning emphasizing fewer content restrictions than the other major providers. Grok’s model performance is competitive but the platform integration shapes its agent product distribution differently than the other providers.

When to Use It

Every agent deployment chooses at least one foundation model provider. The choice depends on the use case (reasoning-heavy tasks favor Anthropic Claude; broad capability tasks may favor OpenAI GPT; multimodal tasks may favor Google Gemini), the deployment constraints (open-weight requirements favor Llama; on-premises requirements may rule out some providers; regulatory requirements may rule out others), the cost profile (different providers have different price points for different model tiers), and the ecosystem integration (existing infrastructure on AWS, GCP, or Azure may favor specific provider integrations).

Multi-provider strategies are increasingly common: use Claude for tasks where its reasoning shines, GPT for tasks where its tool ecosystem helps, Gemini for multimodal tasks, open Llama for tasks where cost or sovereignty matters. The cost is the operational complexity of managing multiple provider integrations; the benefit is the flexibility to use the right model for each task.

Sources

• anthropic.com, openai.com, ai.google.dev, ai.meta.com, deepseek.com, x.ai

Provider-native agent offerings

Source: Anthropic Computer Use and Claude Code, OpenAI Operator and GPTs, Google Gemini Code Assist and Astra, Meta Llama-based platforms

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

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), computer use (Anthropic Computer Use, OpenAI Operator), 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), GPTs (custom configurations of ChatGPT), Codex (the cloud coding agent), and Operator (computer-use product). 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 Gemini (consumer assistant), Gemini Code Assist (coding agent integrated with Google Cloud), Project Astra integrations (multimodal agent capabilities), and AI Studio (developer platform). Google’s products emphasize integration with Google’s broader ecosystem.

Meta’s positioning is different: rather than shipping vertically integrated agent products, Meta ships open-weight models that other developers build agent products on top of. Llama-based platforms abound; Meta itself focuses on the model 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 (where Anthropic Computer Use and OpenAI Operator lead). 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

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, Windsurf, GitHub Copilot) sit alongside the developer in the editor. Terminal-native and CLI agents (Claude Code, Aider, OpenAI Codex CLI) work in shell environments for deeper multi-file work. Autonomous task delegation agents (Devin, OpenAI Codex cloud, Replit Agent 3) 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.

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

Source: Anthropic Claude Code; Cursor (Anysphere); Windsurf (Cognition, after the 2025 Codeium acquisition saga); GitHub Copilot (Microsoft/GitHub)

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

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 terminal-native coding agent, distributed as a command-line tool. Strong on SWE-bench Verified (Claude Opus 4.7 reaches the high 70s—low 80s percentile range). 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, agent mode for multi-file changes, Background Agents and BugBot for autonomous tasks. 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: AI-native IDE originally built by Codeium, rebranded to Windsurf in late 2024, acquired by Cognition in 2025 after the dramatic 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). Cascade is the differentiating agent feature, providing deep automatic codebase context. Pricing is competitive with Cursor; ownership by Cognition (the Devin company) means integration with Devin’s autonomous capabilities is the strategic direction.

GitHub Copilot: Microsoft’s coding agent with 20M+ users and 90%+ Fortune 100 adoption. The enterprise default. 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 Windsurf for codebase-context-aware AI assistance at a price point competitive with Cursor. 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 (Aider, Cline, Continue) for cases where cost or open-source matter more than polish.

Sources

• claude.com/code, cursor.com, windsurf.com, github.com/features/copilot

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

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

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

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 (released 2025) added Interactive Planning and Devin Wiki (auto-indexed repository architecture docs). Cognition slashed pricing from $500/month to broader-adoption tiers in late 2025; enterprise pricing for the Team tier is $500/mo as of May 2026 with custom enterprise tiers above. Best for delegating complete tasks and walking away; less suited for tasks requiring tight collaboration.

OpenAI Codex (the 2026 reincarnation): GPT-5.x-powered cloud coding agent with Codex Desktop as the local interface. Cloud task-runner pattern: define a task, run it in OpenAI’s managed environment, receive a PR. Less autonomous than Devin (the agent doesn’t maintain its own persistent environment) but more integrated with OpenAI’s broader tooling. Strong on certain benchmark dimensions (SWE-bench Pro reaches mid-50s range; Terminal-Bench 2.0 above 75%).

Replit Agent 3: 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.

Use cases that fit autonomous coding agents: migrations (Nubank used a fleet of Devins to migrate 6M lines of code, reporting 8—12x engineering efficiency gains); 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

• cognition.ai/devin, openai.com/codex, replit.com/agent

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

Source: Aider (github.com/Aider-AI/aider); Cline (github.com/cline/cline); Continue (continue.dev); OpenCode and related projects

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

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

Aider: terminal-based AI coding with Git as a first-class citizen. 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. The strongest open-source option for terminal-based coding. 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). Less aggressive on the agentic frontier than Cline; more focused on configurable AI-assisted coding with the developer in control. Fits developers who want AI assistance without the autonomy-heavy patterns.

Choice criteria: Aider for terminal-native workflow; Cline for IDE-based autonomous-ish workflow; Continue for AI assistance with explicit developer control. 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

• aider.chat, cline.bot, continue.dev

Section C — Agent frameworks

LangChain/LangGraph, OpenAI Agents SDK, AutoGen, CrewAI, PydanticAI --- 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. AutoGen, CrewAI, and PydanticAI 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.

LangChain and LangGraph

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

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

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, LangServe for deployment, LangChain Hub for prompts and templates) 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.

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 (Volume 12 referenced), LangServe for deployment, LangChain Hub for prompts and templates, LangGraph Studio for visualization and debugging. 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 or Anthropic Agent SDK for provider-native development. PydanticAI for typed-Python with lighter abstractions. AutoGen 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

OpenAI Agents SDK and Anthropic Agent SDK

Source: OpenAI Agents SDK (github.com/openai/openai-agents-python); Anthropic Agent SDK (anthropic.com)

Classification Provider-native agent frameworks from the two leading foundation model providers.

Intent

Provide first-party agent frameworks from foundation model providers, with tight integration with the provider’s underlying API capabilities and updates aligned with model releases.

Motivating Problem

LangChain’s breadth comes with abstraction costs that not every team wants to pay. The foundation model providers have shipped their own agent frameworks designed to expose their models’ capabilities directly without LangChain’s additional abstraction layer. OpenAI Agents SDK (the successor to the earlier Swarm experimental framework) and Anthropic’s Agent SDK are the provider-native options as of mid-2026. The trade-off is less abstraction overhead but tighter coupling to a single provider.

How It Works

OpenAI Agents SDK: Python framework focused on OpenAI’s Responses API and Chat Completions API. Provides agent loop primitives, tool calling, handoffs between agents, structured outputs, and integration with OpenAI’s broader tooling. The framework matured from the earlier Swarm experimental release; the stable API as of 2026 is the recommended OpenAI-native development path.

Anthropic Agent SDK: Python and TypeScript framework focused on Anthropic’s Messages API. Provides agent loop primitives, tool calling, MCP integration, extended thinking, and Claude-specific capabilities. The framework integrates closely with Claude’s tool-use patterns and benefits from updates as Claude’s capabilities evolve.

Provider-specific trade-offs: tight integration with one provider’s capabilities means the framework can expose features the provider ships immediately, but it means the framework is less portable to other providers. Teams committed to a single provider gain depth; teams that need multi-provider portability gain less.

Comparison to LangChain: the provider-native frameworks are simpler in scope (one provider, fewer integrations) and easier to learn (less abstraction surface). They’re less appropriate for multi-provider deployments and for use cases where LangChain’s broader ecosystem provides value. The choice often comes down to whether the team’s strategy is single-provider or multi-provider.

When to Use It

Single-provider deployments where tight integration with one provider’s capabilities matters. Teams that find LangChain’s abstractions over-engineered for their use cases. Cases where provider-specific features (Claude’s extended thinking, OpenAI’s structured outputs) are central to the agent’s design.

Alternatives --- LangChain/LangGraph for multi-provider or ecosystem-heavy deployments. Direct API integration where even the provider-native SDK adds overhead. PydanticAI for typed-Python with lightweight abstractions across providers.

Sources

• github.com/openai/openai-agents-python

• docs.claude.com (Anthropic Agent SDK)

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

Source: AutoGen (microsoft.com/research, Microsoft); CrewAI (crewai.com); PydanticAI (ai.pydantic.dev); Vercel AI SDK (sdk.vercel.ai)

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

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

AutoGen: Microsoft’s open-source multi-agent framework, focused on conversation-based multi-agent patterns. Strong in research and prototyping for multi-agent systems where the agents communicate through structured conversation. Less polished for production single-agent deployment than LangChain or provider-native SDKs. Best for explicit multi-agent use cases.

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 AutoGen’s flexibility provides.

PydanticAI: 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 with first-class support for generative UI (Volume 13 covers). Strong for web frontend agent development where the generative UI primitives (useChat, useUIState) are central to the application. Less appropriate for backend-heavy Python agent development.

When to Use It

AutoGen for research and prototyping multi-agent systems where conversation-based coordination is the pattern. CrewAI for production multi-agent systems where the role-based abstraction fits. PydanticAI 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/autogen, crewai.com, ai.pydantic.dev, sdk.vercel.ai

Section D — Vertical agent products

Customer support, sales, 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. Sales and marketing have established players with growing adoption. 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.

Customer support agents (Decagon, Sierra, Intercom Fin)

Source: Decagon (decagon.ai); Sierra (sierra.ai); Intercom Fin (intercom.com/fin)

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

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; Intercom Fin leverages Intercom’s existing customer support platform 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.

Intercom Fin: AI agent built on Intercom’s existing customer support platform. Benefits from Intercom’s existing position in mid-market customer support; the AI agent is one of several modes (alongside human agents, chatbots, and self-service) in the unified platform. Fits companies already on Intercom or considering Intercom for the broader platform value.

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 as voice AI matures. 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, Intercom traditional features) where AI agent adoption isn’t yet the right move.

Sources

• decagon.ai, sierra.ai, intercom.com/fin

Sales and marketing agents (11x, Clay, Apollo AI)

Source: 11x (11x.ai); Clay (clay.com); Apollo with AI features (apollo.io)

Classification AI agents for sales prospecting, outreach, and marketing operations.

Intent

Automate sales and marketing workflows through AI agents that handle prospecting (identifying and researching leads), personalized outreach (drafting and sending emails at scale), and pipeline operations (qualifying leads, scheduling, follow-up).

Motivating Problem

Sales and marketing operations have characteristic patterns AI agents can automate: research that scales linearly with the number of leads, personalized outreach that benefits from per-lead customization but doesn’t require deep human judgment for most cases, lead qualification that follows defined criteria. The vertical has produced credible products through 2024—2026, with 11x and Clay as visible leaders alongside AI-enhanced features in established platforms (Apollo, Outreach, Salesloft).

How It Works

11x: AI agents (“Alice” for outbound sales, “Jordan” for content) that handle complete workflows rather than augmenting humans. The agent identifies prospects, researches them, drafts and sends personalized outreach, handles follow-up. Pricing reflects the labor-replacement positioning (substantially higher than per-seat SaaS, lower than full SDR salaries).

Clay: AI-powered data enrichment and outreach platform. Less autonomous than 11x; more of a powerful workflow tool for human-driven sales teams. Strong on data enrichment (combining multiple data sources to build prospect profiles) and automation of complex prospecting workflows.

Apollo with AI features: incumbent sales platform that has added AI features to its existing offering. Less aggressive on the autonomous-agent frontier than 11x but with significant existing market position and integration with sales workflows.

Pattern across products: integration with sales infrastructure (CRM, email, calendar) is the primary engineering challenge; the AI capability is necessary but not sufficient. Customer data and the customer’s ICP definitions shape the agent’s effectiveness; AI agents need substantial setup investment to reflect the specific company’s sales approach.

When to Use It

Companies with significant sales prospecting and outreach operations. Cases where the volume of prospecting work justifies AI automation. Companies willing to invest in setup to define ICPs, messaging frameworks, and workflow integration.

Alternatives --- traditional sales tools (Outreach, Salesloft, traditional Apollo) where AI agent adoption isn’t the right move. Custom development on agent frameworks for companies with unusual sales approaches. Direct foundation model API integration for highly customized workflows.

Sources

• 11x.ai, clay.com, apollo.io

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

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

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

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 (consumer and enterprise): AI-powered web research with citations as a first-class UX element. The consumer product (Perplexity Pro) is the most visible product; 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 (Section F) where vertical depth isn’t needed.

Sources

• harvey.ai, hebbia.ai, glean.com, perplexity.ai

Section E — Computer use and browser agents

Anthropic Computer Use, OpenAI Operator, 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 Computer Use and OpenAI Operator are the major foundation-model-provider-native products. 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.

Anthropic Computer Use, OpenAI Operator, and Browserbase

Source: Anthropic Computer Use; OpenAI Operator; Browserbase (browserbase.com); related computer-use offerings

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

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. Deployment options include cloud-hosted environments (Anthropic-managed sandboxes) and self-hosted (the customer provides the sandboxed environment). The capability has matured through 2024—2026 with significant improvements in accuracy and latency.

OpenAI Operator: similar capability with OpenAI’s model and infrastructure. Browser-focused rather than full desktop in the consumer product; full desktop in enterprise contexts. The competitive positioning vs. Anthropic Computer Use 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.

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

• claude.com/docs/build-with-claude/computer-use

• openai.com/operator

• browserbase.com

Section F — Consumer AI assistants

ChatGPT, Claude.ai, Gemini, Perplexity, Grok --- the consumer-facing AI assistant market

Consumer AI assistants are the most visible AI agent products by user count and market awareness. ChatGPT has the largest share by far (multi-hundred-million weekly active users); Claude.ai, Gemini, Perplexity, and Grok occupy meaningful positions in different segments. The category isn’t enterprise-relevant in the way the prior sections are --- most enterprise procurement is for vertical or framework solutions --- but the consumer products shape user expectations of agent UX and influence enterprise product design through that.

Consumer AI assistants (ChatGPT, Claude.ai, Gemini, Perplexity, Grok)

Source: OpenAI ChatGPT; Anthropic Claude.ai; Google Gemini; Perplexity; xAI Grok

Classification Consumer-facing AI assistants with distinct positioning and capabilities.

Intent

Provide consumer-facing AI assistants for general-purpose use --- questions, writing assistance, coding help, research, creative work --- with each product taking a distinct positioning on capability, integration, and content policy.

Motivating Problem

The consumer AI assistant market is the most visible part of the agent product landscape. The five major products as of 2026 take different positions: ChatGPT as the broad-capability default; Claude.ai as the reasoning and writing emphasis; Gemini as the Google-integrated multimodal option; Perplexity as the citation-first research alternative to traditional search; Grok as the X-integrated and less-content-restricted alternative. The market is large enough that all five are viable; the positioning differences matter for which product fits which user.

How It Works

ChatGPT (OpenAI): the largest by users and brand awareness. Free tier provides general access to GPT-5.x-class models with usage limits; ChatGPT Plus provides higher limits and access to more capable models; ChatGPT Team and Enterprise extend to organizational deployments. The product includes Canvas (artifact-like workspace), GPTs (custom configurations), tool integrations (web search, Python execution, image generation, voice), and a continuously expanding feature surface.

Claude.ai (Anthropic): consumer interface for Anthropic’s Claude family. Strong on reasoning, writing, and coding tasks. Artifacts (Volume 13 covers) for substantial generated content. Projects for organizing related conversations. The consumer product (Claude Pro, Claude Team) competes with ChatGPT for general consumer and team use; the API is the broader Anthropic business.

Gemini (Google): consumer interface for Google’s Gemini family. Strong multimodal capabilities (image understanding, video, audio). Deep integration with Google Workspace (Gmail, Docs, Sheets, Drive). The product’s position is heavily shaped by Google’s broader ecosystem advantages.

Perplexity: AI-powered research with citations as a first-class UX feature. Less general-purpose than ChatGPT or Claude.ai; more focused on factual research and web synthesis. The product competes with traditional search engines and AI assistants on different fronts.

Grok (xAI): integrated with X (formerly Twitter); positioning emphasizes fewer content restrictions and access to real-time X data. The product appeals to users who prioritize these specific positions over general capability comparisons.

Market position: ChatGPT dominates by user count but the other products hold meaningful positions in specific segments. Many users use multiple products; the products don’t require exclusive commitment. Enterprise procurement of consumer-tier AI assistants is increasingly common (Team and Enterprise tiers across the products); the enterprise relevance is in workforce productivity rather than as platform for building applications.

When to Use It

Individual productivity (general assistance, writing, research, coding help). Team productivity where the consumer-grade AI assistants meet the need. Companies evaluating AI capability before building custom solutions. Cases where the broad capability of a consumer assistant beats the vertical depth of specialized products.

Alternatives --- vertical agents (Section D) for domain-specific work. Framework-based development (Section C) for custom agents. The choice depends on whether the use case fits a general-purpose assistant or requires vertical depth or customization.

Sources

• chatgpt.com, claude.ai, gemini.google.com, perplexity.ai, grok.x.ai

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; Helicone, Braintrust, Galileo for broader markets), and enterprise-governance-emphasis options.

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

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

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

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: open-core observability platform with strong product emphasis on evaluation and prompt management. Open-source self-hosted; commercial cloud option. Framework-agnostic. Competes with LangSmith on Phoenix; takes positions that don’t require commitment to LangChain.

Helicone: emphasis on cost optimization and caching alongside observability. Open-source proxy that sits between agents and foundation model APIs, providing visibility, caching, and cost optimization. Different positioning from the pure observability options.

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: enterprise 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. Helicone 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, arize.com/phoenix, langfuse.com

• helicone.ai, braintrust.dev, galileo.ai

Section H — Discovery and tracking

How to keep this snapshot current as the product landscape evolves

The product landscape changes faster than any snapshot can keep up with. The discovery infrastructure that keeps the picture current matters more than any specific snapshot. Several resource categories help: industry analyst coverage (Gartner, Forrester for enterprise; specialist analysts for AI specifically), product hunt and similar discovery platforms (for emerging products), AI-focused publications and newsletters (Stratechery, Ben’s Bites, AI Tidbits, others), and the broader tech press as it covers major product announcements and acquisitions.

Tracking the agent product landscape

Source: Multiple industry analyst, press, and discovery platform sources

Classification Resources for staying current with agent product developments.

Intent

Provide pointers to the tracking infrastructure that documents agent product developments --- new products, acquisitions, repositioning, deprecation --- with sufficient currency that procurement and architectural decisions reflect the actual state of the market.

Motivating Problem

Any printed catalog of agent products ages quickly. The Windsurf saga of 2025 (covered in Chapter 1) is a vivid example: a snapshot from April 2025 would have shown Windsurf as an independent leader; a snapshot from July 2025 would have shown the Cognition-owned product. Major acquisitions, repositioning, and category consolidations happen continuously. Keeping current requires deliberate tracking infrastructure, not periodic reading.

How It Works

Industry analyst coverage: Gartner Magic Quadrants for relevant categories (conversational AI, AI development tools, etc.); Forrester Waves; specialist analysts (a16z’s AI-focused content; Information Industry analysts). The depth and rigor vary; the analyst coverage tends to lag the most current developments by months but provides structured comparison.

Tech press: TechCrunch, The Information, Bloomberg, Reuters, and similar publications cover major product announcements and acquisitions. The signal-to-noise ratio varies; specific reporters and beats are more reliable than general coverage.

AI-focused publications and newsletters: Stratechery (subscription-based analysis from Ben Thompson); Ben’s Bites; AI Tidbits; Latent Space; The Batch (deeplearning.ai); ChinaTalk (for China-specific AI coverage); others. The category is varied; sampling several sources catches different aspects of the landscape.

Vendor blogs and announcements: each major provider has an active blog with product announcements. Following the vendors directly catches new releases sooner than analyst or press coverage.

Product Hunt and similar: for emerging products in earlier stages. The signal is noisy (many products on Product Hunt don’t become production-relevant) but emerging products that later become category leaders often surface here first.

Conference proceedings: Anthropic Builder Day, OpenAI DevDay, Google I/O, and adjacent events surface new products and positioning. The recordings are often the first comprehensive view of new product releases.

Practical pattern: most teams maintain awareness through a mix of sources --- specific newsletters subscribed to, specific vendors’ blogs followed, periodic check-ins on analyst reports for structured comparison. The discipline is investing in tracking infrastructure rather than relying on ad-hoc discovery.

When to Use It

Any organization with agent product procurement decisions that need to reflect the current market state. Strategic planning for AI deployments where the landscape direction matters. Vendor relationship management where understanding the competitive position helps negotiation.

Alternatives --- outsourcing tracking to industry analysts or consultants. The cost-benefit depends on the scale of AI investment and the team’s capacity for internal tracking.

Sources

• Gartner.com, forrester.com (analyst coverage)

• Stratechery.com (Ben Thompson)

• Ben’s Bites (newsletter), AI Tidbits (newsletter), Latent Space (podcast and newsletter)

• Vendor blogs (anthropic.com/news, openai.com/blog, etc.)

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 mid-2026.

Category	Density	State of consolidation	Leaders / examples
Foundation models	Crowded	6 major providers	Anthropic, OpenAI, Google, Meta, DeepSeek, xAI
Agent frameworks	Maturing	LangChain dominant	LangChain/LangGraph, OpenAI Agents SDK, AutoGen, CrewAI, PydanticAI
Coding agents	Crowded→Maturing	8 production-grade winners	Claude Code, Cursor, Windsurf, Devin, Copilot, Codex, Replit, Aider
Customer support agents	Crowded	Several leaders	Decagon, Sierra, Intercom Fin
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, OpenAI Operator, Browserbase
Consumer AI assistants	Crowded	ChatGPT dominant by users	ChatGPT, Claude.ai, Gemini, Perplexity, Grok
Agent observability	Crowded	Multiple credible options	LangSmith, Phoenix, Langfuse, Helicone, Braintrust, Galileo

Appendix B --- The Fourteen-Volume Series

This catalog joins the thirteen prior volumes to form a fourteen-layer vocabulary for agentic AI, 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 a fourteen-volume 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:

1. 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.

2. 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.

3. 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.

4. Provider product lines. Specific products listed for each foundation model provider (Claude Code, Computer Use, MCP for Anthropic; ChatGPT, GPTs, Codex, Operator for OpenAI; etc.) reflect mid-2026 product portfolios. Providers add and retire products continuously; the lists are snapshots, not commitments to maintained product lines.

5. 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.

6. 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.

7. 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.

8. 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.

• 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 Builder Day, OpenAI DevDay, Google I/O, 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 about 14 product clusters across 8 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.

• Voice AI products beyond passing reference. Voice-first AI agents (vapi.ai, retell.ai, others) are an emerging category worth dedicated treatment elsewhere.

• 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 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. 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.

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

— The Fourteen-Volume Series —