You need an AI agent to handle email triage. Or pull together competitive intel. Or automate the weekly reporting that's been eating two hours of your Friday afternoon for the last year.
So you go looking. You search GitHub, browse LangChain Hub, scroll through a dozen Discord servers and Reddit threads. You find plenty of options. Some have 200 GitHub stars. Some have slick landing pages. Some were demo'd in a YouTube video eight months ago.
What you don't find: any reliable signal about whether any of them actually work.
That's the discovery problem. And it's worse than most people admit.
The Ecosystem Is Enormous and Unnavigable
The AI agent space has exploded. LangChain alone has thousands of community integrations and agent patterns. CrewAI has built a framework specifically for multi-agent coordination, and its marketplace of templates grows weekly. AutoGen, Microsoft's contribution to the space, has a sprawling collection of conversation patterns and specialized agents. And those are just the three frameworks everyone's heard of.
Beyond them: Agno, Flowise, n8n integrations, custom GPT wrappers, Dify deployments, Zapier AI agents, Make.com automations. The list keeps growing.
Most estimates put the number of publicly available or semi-public AI agents somewhere north of 50,000. Some people put it much higher. The point isn't the exact number — the point is that the space has grown faster than any discovery mechanism to navigate it.
"The problem isn't that there aren't enough AI agents. The problem is that there's no way to know which ones you can actually stake a workflow on."
When a new software category matures, it usually develops some infrastructure for trust: app stores with review systems, analyst reports, reference customers, certification programs. The agent ecosystem hasn't done this yet. It's still in the "post on GitHub and hope people find it" phase — which was fine when there were 50 notable agents. It doesn't work at 50,000.
The Real Problem Is Trust, Not Search
This is where most people misdiagnose the issue. They think the problem is search — that if someone just built a better index, you could find the right agent.
Search isn't the problem. Finding agents is not hard. Knowing whether to trust one is.
Consider what you actually need to know before deploying an agent into a production workflow:
What trust actually requires
- Does it perform consistently? Not just in the happy path demo, but with messy real-world inputs, partial data, edge cases.
- Is the creator who they say they are? A solo developer hobbyist and an engineering team with enterprise customers are not equivalent — and you can't tell them apart from a README.
- What happens when it fails? Does it fail loudly or silently? Is there an error handling path? Is there documentation for known failure modes?
- Is it maintained? The last commit being six months ago is a data point. No issue tracker response in three months is a data point. A demo built for a conference talk that nobody is running in production is a very different thing from an agent someone's company depends on.
- What are the real costs? Token usage isn't always obvious from a demo. An agent that looks cheap at low volume can become genuinely expensive at scale, and that information is almost never disclosed upfront.
None of this information exists in a GitHub repo's README. Most of it doesn't exist anywhere publicly. That's the gap.
What Happens Without a Trust Layer
The consequences of missing trust infrastructure are not hypothetical. They show up in the same ways, over and over.
The integration tax. Every team evaluating an agent has to build their own testing environment, run their own benchmarks, evaluate their own edge cases. That work is duplicated across thousands of teams. There's no shared knowledge about what works. The same lessons get learned the hard way by different organizations every week.
The demo gap. An agent that runs flawlessly in a 10-minute demo will often fail in different ways at production scale with real data. The demo is optimized for the demo. The README is optimized for initial impressions. Neither is optimized for the thing you actually care about: predictable behavior in a live workflow.
The abandonment problem. How many production systems are quietly depending on an agent that the original creator stopped maintaining two months ago? There's no signal when a project enters maintenance mode versus active development. You find out when something breaks and the bug report goes unanswered.
The provenance problem. Who actually built this? With what libraries? Against what LLM version? This matters because AI agent behavior is version-sensitive in ways that traditional software often isn't. An agent that works well against GPT-4o may behave differently against Claude 3.5. If that information isn't documented — and it usually isn't — you're flying blind.
Why Existing Platforms Don't Solve This
Framework marketplaces like LangChain Hub and CrewAI's template gallery solve a different problem: they make it easy to share and discover patterns. That's genuinely useful. But they're not designed to verify quality, enforce documentation standards, or surface performance data. They're package registries, not trust systems.
General-purpose directories and "awesome" lists solve discoverability but not trust — they're curated by humans who can't evaluate thousands of agents at depth.
Product Hunt is for launches, not for ongoing quality signals. GitHub stars measure attention, not reliability. Reddit threads measure virality, not production-worthiness.
The closest analogues that do work are specialized: AWS Marketplace has verification requirements, financial data providers have audit trails, app stores have review processes. They work because they impose standards — submission standards, documentation standards, performance standards — before anything gets listed.
The agent ecosystem needs that. It just doesn't have it yet.
What a Real Trust Layer Looks Like
Trust in an agent marketplace is built from multiple layers. No single signal is enough. You need a combination:
Creator verification. Not just "does this GitHub account exist" but identity confirmation tied to a real person or organization. Enterprise teams don't deploy software from anonymous creators — agents should be no different. Knowing that a submission comes from a verified individual with a real track record changes the risk calculus entirely.
Tiered quality standards. Not everything has to meet the same bar, but the bar should be explicit. A community-submitted template that nobody has run in production is a different category from an agent that's been deployed commercially and reviewed by a third party. Those tiers should be visible, with clear criteria for each.
Performance transparency. Real ratings from real users who've actually deployed the agent. Error rates, token cost ranges, latency benchmarks where available. The data doesn't have to be perfect — it has to be honest. Even imperfect performance data beats no data at all.
Documentation as a first-class requirement. Not "here's what it does" but "here's what it doesn't do, here are the known failure modes, here's what a production deployment looks like." Bad documentation should be a listing disqualifier, not an acceptable default.
Maintenance signals. Last updated, issue response rate, dependency health. Whether the agent is actively maintained should be visible before you build a workflow around it.
This isn't an impossible standard. It's the standard that mature software ecosystems eventually converge on. The agent ecosystem is just early — and the gap between current practice and what's needed is real and measurable.
What We're Building
OpenDraft is building the trust layer the agent ecosystem is missing.
Every agent listed goes through a review process before it's published. Creators are verified. Documentation standards are enforced. Listings are tiered — Verified, Vetted, and Community — with explicit criteria at each level so you know exactly what level of scrutiny any given agent has been through.
User reviews come from developers who've actually deployed the agents. Performance data is captured where creators choose to share it. Maintenance status is tracked. The goal isn't a comprehensive index of every agent ever built — it's a curated, trustworthy directory of agents that are actually worth deploying.
The discovery problem in this space doesn't get solved by more content. It gets solved by better signal. That's what we're building.
Find agents you can actually deploy
Every listing on OpenDraft is reviewed, documented, and rated by real users. No demos. No dead repos.
Or get notified when new verified agents are listed:
You're on the list. We'll send good ones only.