live reliability oracle

Glimind // docs

Is this tool working right now, and how do I call it correctly — kept current by the agents themselves.

Why use Glimind for agentic workflows

External tool calls are where agentic workflows fail most: the tool is down or rate-limited, or you call it with the wrong shape — and then you burn tokens reasoning about the error and retrying. Glimind answers, before you act, the questions that decide whether a call succeeds. For the agent and the person it works for, that means:

• Fewer failed calls — skip tools that are down/rate-limited right now (neutral 0–100 score + verdict) instead of finding out mid-task; the workflow completes instead of stalling on a dead dependency.
• Fewer wasted tokens — one cheap pre-flight replaces the call → parse-error → reason → retry loop, so you don't spend context or output tokens recovering from avoidable failures.
• Correct on the first try — a known-good input shape and expected output shape, distilled from real successful calls, so you call an unfamiliar tool right the first time.
• Resilience via failover — when a tool is down, get a live capability-matched alternative and route to it automatically (SDK autoRoute); one dead tool no longer breaks the whole run.
• Right timeouts & retries — callHints derived from each tool's real latency and failure patterns, so you neither hang on a slow tool nor give up too early on a recoverable one.
• Less orchestration, less latency — route_task / prepare_tool_call answer "best live tool for X + how to call it + fallbacks" in one round trip (replacing discover + check + prepare + alternatives), with a 60s plan cache (~1.4ms on repeat).
• Higher task success = better UX — every avoided failure and correct-first-time call means the human gets a faster, more reliable result with fewer visible errors.
• Neutral & unconflicted — Glimind sells no tools and runs no integrations of its own, so the ratings aren't talking their own book.
• Zero friction — fast, free for health checks, no signup, privacy-preserving (value-free shapes/metadata only — never your payloads or prompts), and it works from any MCP client, plain REST, or a one-line SDK.

Net: an agent that consults Glimind before external calls wastes fewer calls and tokens, recovers from outages automatically, and finishes more tasks correctly.

For agents

Start a task with route_task(task) — describe what you want and get the single best live tool ready to call (verdict + score + inputSchema + recipe + callHints + ranked fallbacks) in one round-trip. When you already know the tool, call prepare_tool_call(toolId). Other MCP tools: check_tool_reliability, preflight_tools([...]) (vet a whole plan at once), discover_tools(query) (find a live tool — each result carries its inputSchema inline, so you can invoke immediately), get_working_recipe, find_alternatives, find_related_tools, list_breakages, and watch_tool/get_notifications/unwatch for alerts (a pull token — no inbound URL).

MCP (streamable-http): https://glimind.com/mcp
server card:           https://glimind.com/.well-known/mcp/server-card.json
llms.txt (agents):     https://glimind.com/llms.txt  ·  full reference: https://glimind.com/llms-full.txt

REST

method	path	tier
GET	/v1/route?task=	premium* — FLAGSHIP: best tool + how to call it + fallbacks in one call
GET	/v1/health/:toolId · /v1/health?tools=a,b,c	free
GET	/v1/prepare/:toolId?task=	premium*
GET	/v1/search?q=  (results carry inputSchema inline)	premium*
GET	/v1/recipe · /v1/alternatives · /v1/related · /v1/breakages · /v1/demand	free/premium*
GET	/v1/score · /v1/badge · /v1/certification · /v1/profile · /v1/benchmark · /v1/reliability/feed · /v1/eval/export	free/premium*
POST	/v1/ingest (SDK telemetry) · /v1/traces (OpenTelemetry) · /v1/router/profiles (create a router)	free

*Premium reads work without a key at a reduced rate as a free preview. Three self-serve ways to pay, no sales calls: (1) contribute outcomes via the SDK to earn credits, (2) subscribe (Starter $19 / Pro $49 / Growth $199 / Scale $499 — POST /v1/billing/checkout), or (3) x402 pay-per-call in USDC (resend a 402'd request with an X-PAYMENT header — no account). Full ladder + machine-readable payment info at /pricing and GET /v1/pricing. Get a free key at /keys.

Protocols & standards

Glimind speaks the standards the agent ecosystem is built on, so it drops into any stack:

• MCP (streamable-http) — stable handshake + the 2026-07 stateless server/discover. https://glimind.com/mcp
• A2A (Agent2Agent) — consult Glimind as a peer agent. Card: /.well-known/agent-card.json · endpoint /a2a
• Open reliability standard (io.glimind/reliability) — /standard · descriptor /.well-known/reliability.json
• Signed attestations — every score + the feed carry an Ed25519 JWS; verify with /.well-known/jwks.json
• OpenTelemetry — point your OTLP traces at /v1/traces to contribute with zero new SDK (guide)

Reliability router — one endpoint, all your tools, reliability built in

Rather than call Glimind alongside your tools, route your tools through it. Declare your upstream MCP servers once and you get a single MCP endpoint that transparently proxies every call — pre-flighting live reliability, optionally failing over to a healthy in-profile alternative when a tool is down, and recording a privacy-clean outcome. Your calls use your credentials; Glimind is a consented proxy and never invokes your tools on its own.

curl -X POST https://glimind.com/v1/router/profiles -H 'content-type: application/json' \
  -d '{"upstreams":[{"alias":"gh","url":"https://your-github-mcp/mcp"},
                    {"alias":"fs","url":"https://your-fs-mcp/mcp"}],
       "failover":true}'
# → { "token":"rt_…", "endpoint":"https://glimind.com/router/mcp?profile=rt_…" }
# Point any MCP client at that endpoint. Tools appear namespaced as gh__…, fs__…,
# each annotated with its live reliability. Set "forwardAuth":true to pass your
# client's Authorization header through to the upstreams.

Contribute

npm i glimind

import { Glimind } from "glimind";
const glimind = new Glimind(); // defaults to https://glimind.com

// 1) ask before acting
const h = await glimind.check("mcp-registry/acme/search");
if (h.verdict === "down") { /* pick a fallback */ }

// 2) wrap a call — outcome is reported automatically (privacy-clean)
const result = await glimind.wrap("mcp-registry/acme/search", () => acme.search(q));

Privacy

SDK telemetry stores only a salted hash of the input shape, success/failure, a normalized error signature, latency, and a coarse region — never your payloads. Details.

Operators

Probing is liveness + capability only (MCP initialize + tools/list); Glimind never invokes your tools. To opt a server out of probing, see https://glimind.com/opt-out.