Real-time planetary signal engine and Model Context Protocol (MCP) server for autonomous AI agents.
| Endpoint | https://pronto.stream/mcp (streamable-http) |
|---|---|
| Registry version | 0.1.0-beta |
| Now | 15 tools · grade F (49) · pin ts_86fdb0a58fbeb414f0a8435770e30a70 · protocol 2025-06-18 |
| First / last listed | 2026-10-27 06:48 UTC / 2026-10-27 06:48 UTC |
| Grade over time | 2026-10-27: F (49), 15 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: get_billing_profile register_agent open_payment settle_payment get_plans get_latest_signals get_signal search_signals list_fusion_products get_fused_signal scope_signals get_facet_manifest list_facets get_related_signals list_data_sources
get_billing_profile | Report who you are resolved as and what your plan grants: the agent identity behind this call, the funded account it acts for, the plan, the per-minute call ceiling, the per-response row budget, and which indicator set you may compute. Returns a CWF BILL line, a CREDIT line when a metering balance exists, and a NOTE line naming your state and its remedy when you are not entitled — unauthenticated, params: none |
register_agent | Create your own identity on pronto and receive an API key, with no human present. Send the key back as an Authorization header on later calls and you will be recognised across sessions.
Registering grants no plan. A new identity has exactly the limits an unauthenticated caller has. There are two ways to raise them, and you can take either. If you hold your own funds, call get_plans and then open_ params: label, public_key |
open_payment | Buy access for yourself, with no human involved. Step one of two: this quotes the exact amount and binds the purchase to the wallet you will pay from.
Three things can be bought. Call credits: plan "credits" with amount_usd from 1 to 100, at $0.001 a call — one credit per successful tool call, Builder's limits while the balance lasts, no expiry, failed calls not charged. A pass: plan "builder" or params: amount_usd, cycle, from_address*, plan* |
settle_payment | Redeem a payment you have made and activate what it bought — a plan, a pass or call credits. Step two of two, after open_payment and the transfer.
Prove the payment is yours: sign the SIGN message from open_payment with the paying wallet (personal_sign; smart wallets via ERC-1271) and pass it as signature. A transaction hash is public once mined, so without the signature anyone who saw your trans params: signature*, transaction_hash* |
get_plans | List what can be bought — call credits, day and week passes, and plans — what each costs, and what each raises — the call ceiling, the row budget, and whether the commercial indicator set is included. Machine-readable, so you can decide what to do about a refusal without parsing a pricing page: buy the plan yourself with open_payment, or escalate to whoever holds your budget. Returns a CREDITS lin params: none |
get_latest_signals | Fetch the most recent live signals from the wire in token-efficient CWF format, optionally filtered to one collection.
The all-collections view is diversified: no provider may exceed its share of the page, no collection may take more than half of it, and what overflows is named on a note line rather than dropped silently — so a burst of tickers cannot crowd out earthquakes. Pass collection to rea params: collection, cursor, limit, relate |
get_signal | Fetch one signal by its id, when you already know which one you want. Every other read tool returns a set and bounds it, so re-reading a single row through them means re-running a query and hoping the row survives the row budget a second time; this returns that row and nothing else.
Takes either the full correlation id or the short handle in column 2 of any CWF row — cite the handle, pass it back params: correlation_id* |
search_signals | Find signals by the words in them. Use this when you are looking for a subject — a storm name, a company, a phrase a report would print — and cannot name it as a category. When you can name it as a category instead (a country, a domain, a severity), scope_signals selects that slice exactly and does not depend on any particular word appearing; this tool ranks by word overlap and will miss a matchin params: cursor, limit, locale, min_severity, query*, sort |
list_fusion_products | List every derived intelligence product pronto can compute, with the published index or model each one implements, the signal collections it consumes, and whether it needs a plan. Read this to find out whether pronto computes the thing you need, then call get_fused_signal to actually compute it.
The two tools answer different questions and the difference matters. This one states the catalogue, re params: none |
get_fused_signal | Compute derived intelligence products from the live wire. Each result states the method it implements and cites the signals it was computed from; a source row with no citation is labelled as such.
Pick one from the `product` enum, or omit it for everything the current window supports. A product absent from the output has no live inputs right now — list_fusion_products states the whole catalogue a params: product |
scope_signals | Select a slice of the live wire by facet tags — the structured metadata each signal carries, not the words in its text. Use this when you can name the slice you want: every high-severity climate signal in Japan, everything from one provider, everything in one language. It returns the whole slice whatever words the signals happen to use, which is what separates it from search_signals; reach for sea params: cursor, filter, limit, locale, relate |
get_facet_manifest | Read the shape of the wire in one small response: a two-level tree of domain and the topics under it, each with a signal count, ranked so the busiest lead. This is the map to read first — read it once, choose a scope offline, then make one precise call to scope_signals or search_signals instead of guessing a filter.
It covers two facet keys only, domain and topic, and truncates the topic tail und params: none |
list_facets | List the full filter vocabulary: every facet value currently on the wire, across every key — lang, country, region, domain, topic, severity, provider, coverage and place — as one flat list with a signal count each, and a human-readable label for place ids. Every value it returns is a value scope_signals will accept right now.
This is the exhaustive listing and it is long, running to a hundred-odd params: none |
get_related_signals | Follow the link graph from one signal to other signals about the same subject. Each link states the reason the link exists. An echo link marks the same story from several sources. A related link marks a similar signal in the same domain. A cross-domain link joins two domains. For example, a seismic record and a news headline name the same place. The two signals arrive from unrelated providers and params: correlation_id*, limit |
list_data_sources | List the data-source endpoints feeding the wire, with provider, signal type, country, cadence, and license. Returns one SRC line per source. params: signal_type |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.