On this page
How AI Agents Discover Tools, Services, and SaaS Products
A 2026 analysis of 114 AI agent tools found no universal pricing standard, with 7 distinct billing units and a 604x spread between entry plan costs. This pricing opacity stems from a deeper architectural issue: agents can only access tools they are explicitly configured to reach, creating a critical discovery gap that is now the core bottleneck for production agent deployments.
The 2026 AI Agent Pricing Index analyzed 114 AI agent tools and found no pricing standard — 7 distinct billing units in use, 48% of tools combining two or more units, and a 604x spread between the cheapest and most expensive entry plans. That opacity isn’t just a procurement headache. It’s a symptom of a deeper architectural problem the industry hasn’t solved yet: agents can only use what they’re explicitly wired to reach. Everything else might as well not exist.
This is the discovery gap. And in 2026, it’s where the real infrastructure battle is happening — not in model capability, not in benchmark scores, but in how agents find, verify, and connect to the tools they need to do actual work.
The Discovery Problem Is the Bottleneck
A primary practical limit on AI agents is discovery — agents can only use tools, skills, and services they are explicitly configured to reach, creating a need for structured discovery mechanisms. That constraint sounds mundane. It’s actually the single biggest architectural challenge in production agent deployments today.
Think about it from an engineering perspective. You’ve built an agent that can reason, plan, and execute. It needs to pull data from Salesforce, enrich a lead via Apollo, book a meeting through Cal.com, and write a Slack message. Without discovery, you’re hardcoding every single connection. Change an API version, rotate an API key, swap a tool — you’re redeploying. Scale this across dozens of agents and hundreds of integrations, and you’ve built a maintenance nightmare that makes traditional microservices sprawl look organized.
The industry’s answer in 2026 is a mix of open specifications, proprietary registries, and a new category of discovery platforms — each with different assumptions about who should control the catalog, how trust works, and what “discovery” actually means in a production environment.
ARD and Agent Finder: Open Standards Enter the Picture
Google released Agentic Resource Discovery (ARD), an open specification that lets organizations publish tools, skills, agent endpoints, and related metadata where trusted registries can discover them. The idea is straightforward: instead of hardcoding every integration, teams publish resources in a structured way and let approved agents find them dynamically at runtime.
GitHub Copilot launched Agent Finder, which implements the ARD specification to enable agents to dynamically discover and load resources on-demand from curated public or custom private registries. The practical win is significant — agents search an index of available resources in real time and pull in only what they need for a specific task, rather than pre-configuring everything upfront and bloating the context window.
“Agent Finder represents a meaningful shift toward more flexible and intelligent agent orchestration. By implementing an open specification rather than a proprietary solution, GitHub is positioning interoperability and shared standards as core principles.” — BotBeat
The governance model matters here. GitHub emphasizes that agents cannot auto-install resources, and IT administrators can enforce policies defining which resources agents are permitted to discover and use. That’s not a minor detail — it’s the difference between a discovery layer and an attack surface. For a deeper look at how agent discovery protocols like MCP and A2A fit into the broader ecosystem, see our guide on Agent Cards and AI agent discovery.
The Shadow AI Problem: Discovery as Security Infrastructure
Here’s the tension that doesn’t get enough attention: the same discovery capability that makes agents useful also makes them dangerous. Virtue AI launched Shadow AI, an endpoint-level discovery and monitoring layer that identifies where AI agents are running, how they plan and act, and what tools they use. The pitch is blunt — most enterprises have no idea how many unapproved agents are operating inside their environment, what permissions they’ve been given, or what tools they can access.
“Across the enterprise, employees are using unapproved agents for things like coding, data analysis and sales outreach. We built Shadow AI to find them.” — Wenbo Guo, Head of Agent Security at Virtue AI, per SiliconANGLE
This is the underreported story of 2026. The enterprise bottleneck is no longer agent capability — it’s governance infrastructure. Organizations should prioritize investing in agent security (MCP monitoring, shadow AI detection, runtime policy enforcement) over platform selection, because the tools are mature enough that the limiting factor is organizational ability to audit and control autonomous systems, not the technology itself.
Snyk’s Evo Agentic Development Security takes a similar angle, enforcing policy inside the agent execution loop — governing what agents use, what they do, and what they generate — in real time, before risks compound.
Discovery as a Product Category: ProviderScout, Agentcy, and ASAPP
The discovery problem isn’t limited to infrastructure. It’s also a product design challenge. ProviderScout.ai launched an AI provider discovery platform that organizes AI companies into 35 business-focused categories using a Scout Engine that reviews provider websites and public information signals. It’s a directory play — helping businesses find and compare AI tools across categories — but it highlights how fragmented the market has become.
Agentcy’s Intelligent Service Discovery takes a different approach. It automatically routes natural language queries to the appropriate data sources and tools without requiring users to know which specific tool to call. Ask “Why did my conversions drop last week?” and the system figures out it needs Google Analytics, Search Console, and possibly Google Ads — then synthesizes the results into a single analysis rather than dumping raw JSON from three separate sources.
ASAPP’s Discovery Agent works at the enterprise level, analyzing real customer interactions to identify high-impact automation opportunities and required APIs before workflow development begins. It’s discovery applied to the build-vs-buy decision itself — figuring out what to automate before you commit engineering resources to automating the wrong thing.
The Pricing Opacity That Makes Discovery Harder
Here’s where the discovery problem collides with the pricing problem. The 2026 AI Agent Pricing Index found that 53% of AI agent tools offer an ongoing free tier, 17% publish no self-serve price and require contacting sales, and only 13% support self-hosting. The median entry plan for the 90 priced tools is $29/month, with a range from $4/month to $2,417/month.
| Discovery Approach | Pricing Model | Self-Host | Key Tradeoff |
|---|---|---|---|
| Google ARD + GitHub Agent Finder | Free (specification); Copilot plans vary | No | Open standard, but adoption depends on registry ecosystem growth |
| Virtue AI Shadow AI | Enterprise quote | No | Security-first; adds governance layer but requires endpoint deployment |
| ProviderScout.ai | Free directory access | N/A | Helps compare tools, but doesn’t integrate with agent runtime |
| Agentcy | Usage-based | No | Cross-source synthesis, but adds a dependency on Agentcy as intermediary |
| ASAPP Discovery Agent | Enterprise quote (bundled in CXP) | No | Pre-build planning tool; only valuable if you’re already in the ASAPP ecosystem |
| AWS Bedrock AgentCore | $0.0895 per vCPU-hour + $0.005 per 1,000 tool calls | No | Semantic tool search + Agent Registry; AWS lock-in is the real cost |
AWS Bedrock AgentCore provides semantic tool search via its Gateway and includes an Agent Registry for indexing agents across AWS, Azure, GCP, and on-premises environments. But here’s the caveat AWS won’t print: at sustained high throughput, self-hosting wins on cost. And since only 13% of tools support self-hosting, most teams are locked into metered cloud pricing that scales linearly with usage — the exact opposite of the unit economics that make agents attractive at scale.
What I’d Actually Recommend
If you’re building agent infrastructure in mid-2026, here’s the decision framework I’d use — what I call the Autonomy Ladder. Decompose the agent’s autonomy level rather than comparing list prices, because the 604x price spread makes direct comparison meaningless.
Level 1 — Single-agent, single-tool. Hardcode the integration. Don’t over-engineer discovery for one connection. The overhead isn’t worth it.
Level 2 — Single-agent, multiple tools. Use ARD-based discovery (GitHub Agent Finder if you’re on Copilot) to dynamically load tools on demand. This is where the context window savings from dynamic discovery actually matter.
Level 3 — Multi-agent, cross-system. Invest in governance first. Shadow AI detection, MCP monitoring, runtime policy enforcement. The agents are capable enough — the risk is uncontrolled autonomy, not limited capability.
Level 4 — Autonomous, self-optimizing. You’re in territory where self-hosting economics win, but only 13% of tools support it. This is the gap to watch. The teams that figure out how to run autonomous agents at sustained throughput without cloud-metered pricing will have a structural cost advantage that compounds over time.
The open question is whether ARD becomes the enterprise standard or fragments into vendor-specific registries. Google, Microsoft, GitHub, and others are backing open protocols — but enterprise buyers keep choosing platforms based on existing data estates. That tension between open standards adoption and data gravity lock-in will define the next 18 months of agent infrastructure. The discovery layer is where that fight gets settled.