Is There a Better Way to Surface Custom AI Agents?

We built great AI agents—but no one uses them.

The real problem isn’t building agents—it’s finding them

In theory:

• users can switch between agents

• search for them

• bookmark favorites

In practice:

• too many clicks

• too much remembering

• too little context

So what happens?

• users default to the generic AI interface

• custom agents get ignored

Why this happens (especially at scale)

In large environments:

• the number of agents keeps growing

• naming is inconsistent

• users don’t know which one to use

• there’s little in-context guidance

Discovery becomes a memory problem—not a design solution.

What about APIs or custom apps?

The logical next step is:

• build custom UI

• surface agents where work happens

• use APIs to list and trigger them

But today, across most platforms:

• APIs for agent discovery are limited or incomplete

• custom agents are not always accessible across interfaces

• integrations may only support agents created within the same system

There is no universal, standardized way to surface all agents across tools.

So what actually works today?

Not perfect—but effective.

Option 1: Create an “Agent Catalog”

Yes, it sounds basic—but it works when done well.

Instead of a scattered list, create a structured directory with:

• agent name

• purpose

• when to use it

• example prompts

• where it works

This gives users a single source of truth.

Option 2: The “Agent to Find Agents” pattern

This is where things get interesting.

Build an AI assistant whose job is to:

• understand the user’s goal

• ask a few clarifying questions

• recommend the best agent

Output:

• agent name

• when to use it

• a starter prompt

Why this works

It removes the hardest step: “Which agent should I use?”

Instead of:

• searching

• remembering

• guessing

Users just describe what they need.

Implementation tips

Keep it simple:

• limit to your top 10–20 agents

• use consistent naming

• include real examples

• define clear use cases

Too many agents recreate the same problem.

The bigger insight

This isn’t a tooling issue—it’s a behavior issue. Most users:

• won’t browse

• won’t memorize

• won’t explore

They will default to whatever is easiest.

Takeaway

If you’re waiting for the perfect interface to solve agent discovery, you may be waiting a while.

If you design for how people actually work today, adoption improves.

The question isn’t “How many agents did we build?”

It’s “Can users find the right one when they need it?”