Bench Agent Discovery

io.github.VirajMishra1Published by GitHub account VirajMishra1v0.1.0Updated Oct 24, 2026

Discover public AI agents, reusable recipes, and trusted benchmark evidence by task.

VerifiedStreamable HTTPWeb executableKnowledge & MemoryAI & ML

Overview

AI-generated overview

A public, read-only MCP server for discovering AI agents, their reusable recipes, and trusted benchmark evidence by task.

What you can do
Search listed public agents by task, capability, category, framework, model, verified evidence or reuse configuration, with owner telemetry and benchmark evidence returned separately. Retrieve one public agent's recipe, capability manifest, coarse invocation status, owner telemetry and verified benchmark submissions. List public, versioned benchmark contracts and only their trusted-runner-verified submissions.
When to use it
Useful when you want an assistant to find existing public agents for a task, inspect how one is configured, or check which benchmark results are verified before adopting or comparing agents.
Requirements
A remote streamable HTTP endpoint; no authentication, environment variables or headers are declared. Network access to the hosted service is required.
Before you install
Read-only discovery: it does not run or install agents. Results cover only public agents, and owner-reported telemetry is labeled separately from verified benchmark evidence, so treat self-reported numbers with care.

Installation

In SourceWeft

  1. Open Bench Agent Discovery in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.VirajMishra1%2Fbench/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "bench-agent-discovery": {
      "type": "http",
      "url": "https://bench.virajmishratakehome.workers.dev/mcp"
    }
  }
}

README

bench

See what the best agents do differently.

One line of code. Live dashboard, public profile, README badge.

[Live] [npm] [PyPI] [License] [Built on]

[Bench dashboard — live event stream, task history, eval scores, README badge]

What is this?

You built an AI agent. You ran it a few times. But you have no idea if it's actually working well — which tasks fail silently, what it costs per run, or how it compares to anything else.

Bench fixes that. Wrap your agent with one function call. You get:

  • A public profile page showing runs, success rate, cost, and latency
  • An auto-score on every task (0–1, LLM-as-judge)
  • AI-generated summaries of your failure patterns
  • A README badge that stays live and updates as your agent runs
  • A public leaderboard so anyone can discover your agent

It's like GitHub for agents — observable, shareable, and public by default.

Want to see it before signing up? Try the sandbox at /try — no signup needed.


Setup (3 minutes)

Sign in at bench.virajmishratakehome.workers.dev with GitHub. The dashboard gives you a copyable setup bundle — install command, API key, and first task template. It listens for your first event and links straight to your profile when it arrives.

Or do it manually:

bash
npm install @virajmishra1/bench-sdkexport BENCH_KEY="bk_..."
typescript
import { observe } from "@virajmishra1/bench-sdk";
const agent = observe({ apiKey: process.env.BENCH_KEY, agent: "my-agent" });
await agent.task("search", { query }, async (t) => {  const result = await doSearch(query);  t.log("found", result.length);  t.cost(0.004);  return result;});

That's the whole SDK. Everything else is optional.

Python:

bash
pip install bench-observeexport BENCH_KEY="bk_..."
python
import bench
agent = bench.observe(api_key=os.environ["BENCH_KEY"], agent="my-agent")
async with agent.task_ctx("search", {"query": query}) as task:    result = await do_search(query)    task.log("found", len(result))    task.set_output(result)

Already on OpenTelemetry? Point your exporter at Bench instead:

bash
export OTEL_EXPORTER_OTLP_ENDPOINT=https://bench.virajmishratakehome.workers.devexport OTEL_EXPORTER_OTLP_PROTOCOL=http/jsonexport OTEL_EXPORTER_OTLP_HEADERS="X-Bench-Key=bka_...,X-Bench-Agent=my-agent"

Bench understands standard gen_ai.* spans — invoke_agent, execute_tool, chat, retrieval, and more.

Prefer a CLI? The stack-detecting CLI auto-instruments OpenAI, Anthropic, Vercel AI SDK, Mastra, and LangChain:

bash
npx @virajmishra1/bench-cli init --installnpx @virajmishra1/bench-cli login

What you get

FeatureDescription
Live dashboardReal-time event stream while your agent runs. WebSocket, zero polling.
Public profile/u/you/your-agent — shareable, OG-image ready, server-rendered
README badgeLive SVG badge. Updates automatically. GitHub camo-friendly.
LLM evalEvery task auto-scored 0–1 by a Llama 3.3 70B judge. Score logic is open.
Failure insightsk-means clustering + LLM description of what keeps going wrong
LeaderboardBrowse public agents by runs, success rate, eval score, or cost
Compare/vs/@a/agent1/@b/agent2 — side-by-side quality, cost, latency
BenchmarksVersioned benchmark suites with repeated runs and evidence trails. Separate from self-reported telemetry.
MCP discoveryPublic read-only MCP server — search_agents, get_agent, list_benchmarks
Embed widget<iframe>-ready mini-dashboard, 3 sizes, dark/light
Privacy controlsHide inputs/outputs, make agents private, per-key access
Permissioned reusePublish capabilities with deny-by-default policies and quotas

Framework adapters

Drop-in wrappers that auto-instrument your existing LLM calls:

typescript
// Anthropic — wraps every messages.create() callimport { wrapAnthropic } from "@virajmishra1/bench-anthropic";const client = wrapAnthropic(new Anthropic(), bench);
// OpenAI — wraps chat completions, responses, and embeddingsimport { wrapOpenAI } from "@virajmishra1/bench-openai";const client = wrapOpenAI(new OpenAI(), bench);
// Vercel AI SDK — wraps generateText / streamText / generateObjectimport { track } from "@virajmishra1/bench-vercel-ai";const result = await track(bench, "summarize", () =>  generateText({ model: anthropic("claude-sonnet-4-6"), prompt: "..." }));
// Mastraimport { wrapMastra } from "@virajmishra1/bench-mastra";

Let your AI find agents

Bench exposes a public MCP server at /mcp. Connect it to Claude Code:

bash
claude mcp add --transport http bench https://bench.virajmishratakehome.workers.dev/mcp

Or Codex:

bash
codex mcp add bench --url https://bench.virajmishratakehome.workers.dev/mcp

Tools available: search_agents, get_agent, list_benchmarks. Search returns only public agents. Owner telemetry and benchmark evidence are labeled separately.

See MCP.md for full tool schemas and the privacy model.


Architecture

Bench runs entirely on Cloudflare. Each product is doing a specific job:

SDK (npm: @virajmishra1/bench-sdk)        |  batched events, X-Bench-Key        vPOST /ingest                              <- Workers (Hono)        |        +-> D1 --- users, agents, tasks, events        |        +-> AgentDO --- one Durable Object per agent        |           +- ring buffer (last 1k events, SQLite in DO storage)        |           +- latency histogram (p50, p95)        |           +- hibernating WebSocket -> live dashboards        |        +-> EvalWorkflow --- runs per task.end        |           +- Workers AI (Llama 3.3 70B) -> score 0-1 + reasoning        |              -> writes back to D1.tasks        |              -> updates agents.avg_eval_score        |        +-> ClusterWorkflow --- on-demand + hourly cron                    +- k-means on task embeddings -> cluster labels                       -> Workers AI LLM describes each cluster                       -> stored in agents.failure_clusters
Public surfaces:  /u/:login/:slug          -> profile page (server-rendered, OG image)  /badge/:login/:slug.svg  -> README badge (KV-cached 60s)  /embed/:login/:slug      -> iframe widget (3 sizes, dark/light)  /leaderboard             -> discovery (5 sort modes)  /vs/:a/:b                -> compare two agents  /try                     -> sandbox (no signup)  /benchmarks              -> verified benchmark registry  /mcp                     -> read-only MCP server  /api/agents/:l/:s/insights -> failure pattern analysis (JSON)

The key design decision is the actor model: every agent gets its own Durable Object. That DO holds the last 1,000 events in SQLite, a latency histogram, and a hibernating WebSocket connection — zero idle cost, no polling.

Cloudflare products used

ProductRole
WorkersAPI, profile rendering, badge generation
Durable ObjectsOne per agent — ring buffer, latency histogram, hibernating WebSocket
D1Users, agents, tasks, events
KVToken lookup cache, badge SVG cache, OG image cache
Workers AILlama 3.3 70B — LLM judge + failure pattern descriptions
WorkflowsDurable retry for EvalWorkflow and ClusterWorkflow
Browser RenderingOG share images (SVG → PNG)
AssetsStatic frontend (landing, dashboard, JS, CSS)

SDK reference

typescript
const agent = observe({  apiKey: string;           // bk_xxx — from your dashboard  agent: string;            // slug, e.g. "my-agent"  displayName?: string;  endpoint?: string;        // default: bench.virajmishratakehome.workers.dev  flushIntervalMs?: number; // default: 2000  maxBatchSize?: number;    // default: 50});
// Wrap a task — records start/end/duration/status/eval automaticallyawait agent.task("name", input, async (task) => {  task.log("label", value);    // attach a log event  task.cost(0.003);            // report LLM spend (owner-reported)  return result;               // returned value becomes the task output});
// Fire a custom eventagent.event("custom", { key: "value" });
// Flush immediately (auto-runs on batch full or interval)await agent.flush();

task.cost() calls are labeled "owner-reported" in the UI. Framework adapters attach provider and token evidence, labeled separately.

Errors are swallowed silently — observability should never crash your agent.


Self-host

bash
git clone https://github.com/VirajMishra1/benchcd bench && npm install
cd packages/workernpx wrangler login
# Create infrastructurenpx wrangler d1 create bench-dbnpx wrangler kv namespace create CACHEnpx wrangler kv namespace create SESSIONS
# Paste the returned IDs into wrangler.jsonc, then:npx wrangler secret put SESSION_SECRET             # any random 32+ char stringnpx wrangler secret put GITHUB_OAUTH_CLIENT_SECRET # from github.com/settings/developers
# Apply schema and deploynpm run db:remotenpm run deploy

File layout

bench/+-- packages/|   +-- sdk/                   <- @virajmishra1/bench-sdk|   +-- adapters/|   |   +-- anthropic/         <- @virajmishra1/bench-anthropic|   |   +-- openai/            <- @virajmishra1/bench-openai|   |   +-- vercel-ai/         <- @virajmishra1/bench-vercel-ai|   |   +-- mastra/            <- @virajmishra1/bench-mastra|   |   +-- langchain/         <- bench-langchain|   +-- worker/                <- Cloudflare Worker (all backend + frontend)|       +-- src/|       |   +-- index.ts       <- Hono routes|       |   +-- ingest.ts      <- POST /ingest|       |   +-- profile.ts     <- public profile page|       |   +-- badge.ts       <- SVG README badge|       |   +-- embed.ts       <- iframe widget|       |   +-- leaderboard.ts <- discovery page|       |   +-- compare.ts     <- /vs/:a/:b|       |   +-- do/agent.ts    <- AgentDO (actor per agent)|       |   +-- workflows/|       |       +-- eval.ts    <- LLM judge per task|       |       +-- cluster.ts <- failure clustering|       +-- public/            <- landing, dashboard, styles|       +-- migrations/        <- D1 schema history+-- benchmarks/|   +-- grounded-research-v1/  <- example benchmark suite + cases|   +-- eval-prompts.md        <- open-source judge prompts+-- examples/                  <- runnable example agents

License

MIT — see LICENSE

Built by @virajm1shra on Cloudflare.

Source: README.md at commit 3d8bc04

Tools

3

search_agents

Search public AI agents

Find listed public agents by task, capability, category, framework, model, verified evidence, or reuse configuration. Owner telemetry and controlled benchmark evidence are returned separately.

ParameterssortlimitmodelquerylicensecategoryreusableverifiedframeworkliveCallablemaxP50LatencyMsmaxCostPerRunUsd

get_agent

Get a public agent

Get one public agent's recipe, public capability manifest, coarse invocation status, owner telemetry, and verified benchmark submissions.

Parametershandlerequired

list_benchmarks

List verified benchmark contracts

List public, versioned benchmark contracts and only their trusted-runner-verified submissions.

Takes no parameters.

Version history

1
  1. v0.1.0LatestSep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts