AgentNexus.app

Agent Nexus cataloga esa capa: APIs, servidores MCP y CLIs, sondeados continuamente para que un agente sepa qué sigue respondiendo.

Documentación

Agent Nexus

Independent discovery, verification and trust infrastructure for the services AI agents use.

Live: https://agentnexus.app · MCP endpoint (no login): https://agentnexus.app/api/public/mcp

M8ven Score Listed on mcpservers.org

Agent Nexus MCP server on Glama Verified on Appside

Agent Nexus helps autonomous agents find callable APIs, MCP servers and CLIs, inspect observed health and contract evidence, and choose their next step with historical reliability in view. The registry is the foundation, not the whole product: discovery, verification and trust evidence are available through MCP and HTTP.

Discover a service. Inspect the evidence. Call the provider directly. Agent Nexus is not an execution proxy and does not silently reroute calls. Suggested alternatives are advisory; the agent decides whether they meet its requirements.

Listed on the official MCP registry as app.agentnexus/agent-nexus, on Smithery, on Glama, on Appside (owner-verified, live handshake check) and on the M8ven Trust Index.

Integrated into HOL Guard as an opt-in hosted MCP contribution. Read-only tools inherit the user's policy; write tools are review-gated. Inspect the accepted contribution.

Evidence beyond an HTTP 200

Production problemWhat Agent Nexus measuresWhy it matters
A reachable endpoint exposes a broken or changed interfaceSeparate liveness, capability and pinned schema checks; freshness checks for selected data sourcesA successful HTTP response alone is not a clean bill of health
Old and new builds alternate during a rolling deploymentDeclared tool-schema comparisons are scoped to an endpoint and negotiated protocol version; a new shape requires two consecutive matching observations before drift is confirmedReduces false change reports from an A → B → A sequence
One endpoint continues serving different tool shapesComplete observations feed a 24-hour distinct-shape count; recurring shapes spanning at least six hours yield split_fleetMakes persistent inconsistency visible separately from the drift verdict
A later MCP tool-list page failsFollows nextCursor for up to 20 pages; unfinished pagination is labelled PARTIAL with the number of pages checked and tool_list_complete: falsePreserves the last complete list and excludes partial observations from schema baselines and fleet counts
Complete observations stop arrivingHealth cards expose schema.comparison_subject.fleet.complete_observations_24h and last_complete_at; the rolling count is recomputed at read time, and a zero count yields unobserved_24h, not single_shapeDistinguishes an empty evidence window from observed stability without requiring callers to infer it from timestamps
A fleet settled long ago looks like one that settled yesterdayfleet.last_transition carries from_hash, to_hash and transitioned_at for the last confirmed shape change, retained beyond the 24-hour window; fleet.transition_history lists every confirmed transition, oldest first, and is never pruned by the windowSeparates "stable since a dated change" from "no transition recorded"; a null transition or empty history means none was recorded since tracking began, not a guarantee that nothing ever changed, and past changes stay auditable after they leave the card window

The fleet finding describes observed shapes, not the identity or exact number of workers behind a load balancer. Checks are scheduled observations, not continuous guarantees. Local CLI/stdio listings expose package availability evidence rather than claiming that a user's running process is healthy.

observations_24h remains a compatibility alias for the complete-only count. last_complete_at is the latest retained complete observation for the comparison subject, even if older than 24 hours, or null when unavailable. Missing legacy history produces null for the new fields, not invented evidence; its stored verdict is preserved for compatibility, not treated as a newly measured empty window.

With available complete-observation history, zero complete samples in the rolling 24-hour window means fleet.verdict: "unobserved_24h". The last retained complete timestamp remains visible. This state is not a declaration of outage, drift or safety: it says the window contains no complete evidence. A new complete sample resumes the normal fleet classification. Partial and failed probes never refresh this evidence. Existing fields remain available, but consumers that validate a closed verdict enum must accept unobserved_24h. A single_shape verdict means one shape was observed in the window, not continuous availability or a guarantee at execution time.

Inspect the implementation: capability and pagination probes · schema baselines and fleet history · complete-observation gate.

Signed health evidence, bound to the caller

An optional authenticated POST to an entry's health-card URL returns an ES256-signed receipt bound to a verified API-key principal, the target endpoint, stored schema hash, fixed health:read scope and caller nonce. Public GET cards remain available without a key.

  • Maximum lifetime: 120 seconds, shortened when the underlying evidence expires. Signing an observation does not make it newer; observation timestamps and ages remain visible.
  • Completeness is part of the signed evidence. Incomplete MCP pagination cannot produce an up receipt verdict.
  • Verification is explicit. Check the signature against the published JWKS, expected caller and target, nonce, expiry, and your own evidence-age policy.
  • Fail closed. Invalid callers are rejected; unavailable signing returns an error rather than unsigned evidence. Receipt responses are private and not cached.
  • Typed outcomes, not a boolean. cache_hit identifies stored observations, fresh_probe requires observations performed during the probe request, nonce_reuse rejects replay, and verifier_error identifies unavailable verification. Signed receipts bind probe time, expiry, signing key ID, advisory decision, evidence_source (pipeline and canonical card), verifier_build (receipt evaluator version), and decision_expiry (Unix seconds, no later than exp). An observation remains inspectable after decision expiry, but cannot pass acceptance policy. POST reads stored scheduled probes, so normal issuance is cache_hit, not a newly executed probe.
  • Replay protection. A durable, atomic ledger rejects reuse of a nonce by the same verified key principal for 24 hours, across routes and simultaneous requests. HTTP 409 returns a signed nonce_reuse; HTTP 503 returns verifier_error without a receipt or trustworthy probe timestamps. Clients must also atomically consume expected nonces when accepting receipts offline.

A receipt is a signed reference point, not execution authorization, a guarantee of future availability or proof of task completion. An unchanged schema hash does not prove that a downstream failure was caused by the caller; a changed hash does not by itself prove a breaking change. Diagnose failures using the actual request, response and provider evidence.

Receipt contract and verification guide · Site guide · Public signing keys · Live health card example


Connect an agent in one line

New here? Short tutorial for AI assistants · Repository tutorial. Covers remote MCP clients and HTTP tool runners for OpenAI, Mistral, Gemini, DeepSeek, Grok and local models. Client support varies; simply pasting a URL into a chat does not enable tools. Connect, run a real discovery, inspect dated evidence, then complete a safe read-only task. Health evidence never grants execution authority.

Start with a completed task, not just a search: obtain Berlin's weather through a discovered public API. The example below needs Python 3 only, with no account, key, extra packages, or payment. Agent Nexus finds the service; the example calls the provider directly.

Official integrations

ClientInstallation / guide
Pythonpip install agentnexus-client · examples
JavaScript / TypeScriptnpm install agentnexus-client · examples
n8nn8n-nodes-agentnexus · guide + ready-to-import workflow
LangChainlangchain-agent-nexus
CrewAIcrewai-agent-nexus
LlamaIndexllama-index-tools-agent-nexus
Gemini CLIExtension manifest · install with gemini extensions install https://github.com/Strategiumfinancepartner/AgentNexus

Use only the package names linked above; unrelated projects also use the AgentNexus name. A free key gives 1,000 calls/day shared across compatible clients; keep it private. Anonymous discovery remains available at 100 calls/day per source address.

n8n: health-checked email workflow

Workflow builders can import a free template that asks Agent Nexus for a live email provider, checks its current health before sending, and stops (or switches to a fallback you approve) instead of sending into an outage. No key is needed to try it.

Step-by-step guide · Download the n8n template (JSON)

Complete your first task

From a checkout of this repository:

python3 examples/first_weather_task.py

The example discovers Bright Sky, checks the returned no-key contract and expected HTTPS host, then requests Berlin's current weather using the provider's documented /current_weather endpoint. It prints the temperature, conditions and observation timestamp only after receiving a complete provider response. If discovery, the contract or the provider response changes, it stops without claiming success. It never books, pays, creates a key, or submits an invocation report.

Live check on October 30, 2026: discovery and the direct provider request both returned HTTP 200; the observation at 08:00 UTC was 7.5 °C and fog. This is an example result, not a promise of future availability or identical weather. This verification is our own test, not evidence of customer activation.

For a different task, read the returned service's authentication and pricing requirements before calling it. Report an outcome only after an actual invocation; discovery and health probes alone do not prove task completion.

MCP (Streamable HTTP, stateless, anonymous, no consent screen or key):

{
  "mcpServers": {
    "agent-nexus": {
      "type": "http",
      "url": "https://agentnexus.app/api/public/mcp"
    }
  }
}

Or over plain HTTP: an agent can obtain a key and start calling without any human:

# 1. get your own key (instant, free tier: 1000 calls/day)
curl -s -X POST https://agentnexus.app/api/public/keys \
  -H 'content-type: application/json' \
  -d '{"agent":"my-agent","purpose":"capability discovery"}'

# 2. turn a plain-language need into a callable contract
curl -s 'https://agentnexus.app/api/public/discover?need=send%20transactional%20email' \
  -H 'x-api-key: nx_...'

MCP tools

ToolWhat it does
discover_capabilitiesPlain-language need → ranked callable interfaces with auth, formats, limits, reliability
search_registryKeyword search across APIs, MCP servers and CLIs
get_entryFull contract for one interface
list_categoriesBrowse the taxonomy
list_entriesPage through the approved catalogue
report_invocationReport the outcome of an actual downstream call (key required)
submit_entrySubmit an API, MCP server or CLI for human review (member or agent key)
list_my_submissionsReview your own submissions (authentication required)

Machine-readable surfaces

SurfacePurpose
/llms.txt, /agents.txtHow an agent onboards itself, unattended
/api/public/registryFull typed registry
/api/public/capabilitiesCapability index
/api/public/entries.ndjsonStreamable bulk export
/api/public/statusUptime history and recent incidents
/api/public/health-card/<slug>Per-entry health, contract and fleet evidence; optional signed receipt via POST
/.well-known/jwks.jsonPublic keys for health-receipt verification
/openapi.json, /server.jsonOpenAPI + MCP server manifest
/.well-known/mcp.json, /.well-known/agent-card.jsonDiscovery manifests
/feed.xmlNew and updated interfaces

Human pages

/explore · /connect · /status · /pricing · /keys

Case studies

  • Remote Jobs API (Nova): 14-day freshness pilot: 1.01M → 1.46M live listings, 32 → 82 sources, all 82 reporting source_last_updated, 100% probe reliability. Approved by Nova. Web version

Live demos & articles: 5 live demos (geolocation, payments, web search, 3-way comparison, advisory alternatives when a service is down) computed from the registry at page load. Articles: How AI agents discover tools · MCP reliability · Discovery & trust layer.

Tiers

TierWho it is forDaily calls
AnonymousTrying it out, no account100
Free keyAgent developers1 000
Agent ProProduction agents that must not stall50 000
PublisherAPI / MCP / CLI vendors: verified badge, listing report, confirmed-outage, structure-change and per-source stale-data alerts (email + signed webhook)Not applicable

Stack

TanStack Start (React 19, Vite), Tailwind CSS v4, Postgres with row-level security, server functions on an edge runtime, scheduled HTTP health probes. Built with Lovable.

Only publishable keys live in this repository; every secret is held server-side.

Development

git clone https://github.com/Strategiumfinancepartner/AgentNexus.git
cd AgentNexus
npm i
npm run dev

Agent Nexus · support@agentnexus.app

Publisher alerts

Publisher-plan entries get alerts on what actually breaks agents, not just "it answers":

  • Confirmed outage: sent only after 2 consecutive failed checks, plus a recovery notice. The scheduler runs hourly over a rotation of the catalog (each service is re-verified roughly every 18 hours on average); a service whose last check failed jumps the queue and is rechecked on the next hourly cycle, so an outage is usually confirmed within about an hour of the first failure. Outages shorter than that can be missed.
  • Structure change: the response no longer matches its documented contract.
  • Field-level change report: confirmed tool-schema changes are listed field by field. Breaking changes (declared_tool_schema_breaking_changes: removed, retyped, lost enum value, newly required) are public; for Publisher entries the health card also lists additive changes in declared_tool_schema_additive_changes (new tool, new optional field, gained enum value, input became optional), labeled non-breaking by default. The consumer decides whether a change matters; null means not exposed, not "nothing changed".
  • Stale data per source: e.g. "12 of 83 sources not updated for 24h+", with your own age and volume thresholds. One alert per change, no repeats.
  • Per-source volume: an alert when any single source drops to zero live records (even if the overall total looks healthy), when it loses more than a chosen share since the previous hourly check (80% by default), and when it comes back.
  • Delivery: email and webhook signed with x-agentnexus-signature: sha256=<HMAC-SHA256 of raw body>; failed sends are retried up to 5 times; test button and 30-alert history on your entry page.

Live evidence for any entry: GET https://agentnexus.app/api/public/health-card/<slug> (includes data_quality and outage).