SigB for machines

SigB, for machines

SigB maintains source-backed state for the entities and events of a changing public world, and serves it to systems that reason about that world. One MCP endpoint carries the whole desk: grounded answers that state their own verification status, entity dossiers, event arcs, published prices, and a purchase path with prices stated before anything is spent. Stable schemas, an explicit evidenceStatus on every signal (receipted rows carry the source URL behind each claim; unreceipted rows are labeled as leads), and freshness stamps your agent can check rather than trust. No key and no login for reads. This page is the guided map and the full integration contract; the endpoint itself is the authority.

Currency states. Every record carries one of three: current, not-reliably-current (a source is behind; the record says which and since when), or cannot-measure (we could not look, which is not the same as nothing found). A “current record” is maintained state with a stated as-of date, not real-time or complete observation.

The endpoint

POST https://api.signalbureau.ai/api/mcp          # MCP (JSON-RPC 2.0) — tools, resources, prompts
GET  https://api.signalbureau.ai/api/openapi   # REST contract (OpenAPI)
GET  https://sigb.ai/llms.txt      # integration notes for AI agents

• Auth: none for reads — serverInfo says auth: "none" so setup flows can discover it.
• Call https://api.signalbureau.ai — the machine door: the same API on a host with no browser checks, where any User-Agent is welcome. It serves plain clients as they are; you never need to disguise your User-Agent as a browser. A 403 mentioning code 1010 means you are on the www host — switch to api. and it clears.
• Full MCP surface: tools/list, resources/list, prompts/list (canonical workflows: morning-read, look-around, coverage-quote).
• Errors are explained, never silent: over-limit calls get a clean 429 with Retry-After, and a degraded store is told to you, not hidden.

Connect your AI over MCP

SigB speaks MCP over Streamable HTTP: each JSON-RPC 2.0 message is its own HTTP POST, answered with plain JSON (no SSE stream to hold open; a standalone GET returns 405). The server is stateless and issues no session ids. Protocol version is negotiated at initialize: current revisions through 2025-11-25 are fully supported, and the 2024-11-05 message version is accepted for clients that can initialize over this endpoint — the deprecated 2024-era HTTP+SSE transport is not provided. Standard clients follow the normal lifecycle (initialize → notifications/initialized → tools/list → tools/call). As a SigB convenience extension, direct tools/call without the handshake also works for lightweight stateless integrations. No key for the read tools.

{
  "mcpServers": {
    "signal-bureau": {
      "url": "https://api.signalbureau.ai/api/mcp"
    }
  }
}

The config above points at the machine door, https://api.signalbureau.ai.

Don't take our word for it: look this server up in the official MCP registry — the registry's own search for our name, answered by their host, not ours. Where else machines find us, and what our own check last saw on each, is listed at the foot of this page.

The REST feed

One GET, no key. Returns the current flags — each with name, trajectory (direction + % change), the domains it's spreading across, desk membership, top evidence with source URLs, and a pre-phrased follow-up question for the Answer Engine. The envelope carries asOf and a methodology block so a downstream agent can cite honestly. Schema sb.signals.v1: additive changes only — fields are never renamed or removed within a version.

curl -s "https://api.signalbureau.ai/api/signals?limit=5"

Filters: ?limit=N caps the list; ?direction=rising (or fading, steady, new) filters by trajectory. Responses are edge-cached for 10 minutes; the underlying snapshot is rebuilt on a multiple-times-daily schedule (three timed builds today) and every payload stamps its own generatedAt — trust the stamp, not this sentence.

Freshness, defined per layer. We read every subject area we cover at least once a day; prediction-market prices and fast-moving desks are read again during the day. Entity and event state updates with the daily build and with updates during the day. The published feed is the snapshot above, rebuilt on that schedule. Answers are computed when you ask, against the latest build.

Three coverage counts. The coverage object in the feed reports how many subject areas are set up (registered), how many are being read on schedule today (activelyScraped), and how many the currently flagged entities draw evidence from (spannedByFlaggedEntities, which moves with the news). Where a page shows one number, it is one of these three.

The tools

Call start_here first; one call returns the whole picture. Then call traverse to walk the record. tools/list serves 29 tools today, grouped by job below in the order the door serves them, and it is authoritative if this page and the endpoint ever disagree. Every tool also carries the standard MCP annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint), and each one below says in words whether it only reads or what it writes.

Walk the record: a first walk in three calls

To see how the record fits together, start at an entity or event (e.g. Hormuz) and traverse its maintained relationships; each step returns its relation type, receipts, standing and time. traverse opens one node of the record per call: an entity, a situation, a claim or a relation. Each node carries its standing as five separate records (evidence, admission, disposition, validity, measurement), its receipts with source urls, and its neighbours as counts plus typed ids, with a cursor for the next page. One level per call; follow any id it returns to take the next step. Free, no key.

1. Open an entity by name. traverse {"id":"entity:hormuz"}, or GET /api/v1/node?id=entity:hormuz. Returns the entity, its standing, its receipts (children), and the situations and claims it is named in (relations).
2. Follow a claim. traverse {"id":"<a relations.items[].id whose kind is claim>"}, or GET /api/v1/node/p/{hex}. Returns the claim in its sources' words, whether it is corroborated, single source or contested, and who carried it.
3. Open its sources. traverse {"id":"<the same claim id>","level":"children"}, or GET /api/v1/node/p/{hex}?level=children. Returns every receipt as an observation with the publisher, the date and the url; open the url to read the source itself.

Ids after the first are read off the previous answer. The REST twin is GET /api/v1/node/{kind}/{hex} on https://api.signalbureau.ai.

The async ask pattern

We optimize for a quality answer over a fast one, and sync and async are different contracts, stated separately. So ask is async by default: submit, get the claim ticket, keep working, collect when ready. The question is metered once, at submit; collecting is free. If the ticket store is briefly unavailable the full answer comes back synchronously instead — handle both shapes. A working ticket reports elapsedSeconds, and past the stated range it also carries late: true with a message naming that range — late is not lost; a run is only reported lost past 300 seconds. We spend the seconds a grounded, source-checked answer takes — built for the internet of machines that need current state, not for millisecond trading.

-> tools/call ask        {"question": "..."}
<- {"status": "working", "ticketId": "..."}      # ~1s
-> tools/call get_answer {"ticketId": "..."}     # poll; typically 30-120s
<- the finished answer, with its served/abstained status and verification state (or {"status":"working","elapsedSeconds":N,"late":true} — try again)

# every answer states what the verdict did to its own prose:
#   servedAs           "verified" | "as-written" | "evidence-bounded" | "abstained"
#   verificationState  "verified" | "unverified" | "cannot-measure"  (verified's three states, in words)
#   verificationReason the pass that failed, in one token
#   abstained          always a boolean — an abstention is our decision, never an unknown

# REST equivalent: POST /api/ask {"async": true} then GET /api/answer/<ticketId>

Every answer states what the verdict did to its own prose: servedAs is "verified", "as-written", "evidence-bounded" (a sentence stating more than its sources establish was replaced with what they do establish) or "abstained" (the conclusion was withheld); verificationState spells the three states of verified in words — "verified", "unverified", "cannot-measure" — with verificationReason naming the pass that failed; abstained is always a boolean, because an abstention is our decision and never an unknown.

Ask it questions over HTTP

A plain JSON endpoint. One question in; a structured read out, checked against sources with the result disclosed.

# one-time: mint your free key (instant, no card)
curl -s -X POST https://api.signalbureau.ai/api/keys -H "content-type: application/json" \
  -d '{"label":"my-agent"}'
# then ask (25 free answers on your key, for its lifetime — they do not reset)
curl -s https://api.signalbureau.ai/api/ask \
  -H "content-type: application/json" -H "x-api-key: $SB_KEY" \
  -d '{"question":"What changed for Taiwan this week?"}'

Live platform metrics, assembled on demand by a stateless worker:

curl -s https://api.signalbureau.ai/api/stats

What costs money and what is free

The daily brief, the record, the calibration table, and every correction are free for anyone. Charges meter work done on your behalf.

Rates change forward-only with 30 days' published notice, and every past revision is kept on our record. The machine-readable rate card is /api/tariff; price a basket from your own requirements with get_quote — quotes need no contact details and are never a charge. Checkout runs on Stripe’s hosted page with prices published first and nothing hidden; rehearse with create_order {dryRun: true}.

Built for teams

The evaluation motion is concrete: give us the concerns your team cannot afford to stop watching — the entities, programs, exposures, and questions, as many as the work takes — and we will stand up a private desk against it, baseline every name, and deliver daily briefings plus full API access for a 30-day evaluation. That is the Private Desk Pilot ($5,000 once), and it ends with a written acceptance report against the metrics in the agreement — details on the pricing page.

SigB is a commercial intelligence platform, running entirely on stateless edge workers. High-throughput access, webhooks and push delivery, and domain-scoped feeds are being wired with early partners now; service commitments are set per contract. Tell us what your system needs and we'll wire you in.

Talk to us about enterprise access → (lead [at] evfm.co)

Why not just ask an AI?

We may not be for you. If a wrong or stale answer costs you nothing, free search or a general-purpose chat model is the right tool, and we will say so. If staleness or error has a price (a filing, a shipment, a trade, a briefing someone acts on), a source-traced, verified, graded answer is the cheapest item in the decision path.

Quotas and limits, stated

• Open API / MCP (free, keyless reads and a daily keyless Answer Engine allowance · a free self-issued key for your own meter): 500 signal-feed reads per day.
• Metered API (identified API key, billed on what you use at the published prices): Watches at $20 a month each, with nothing preset (Your first five Watches are on us while we open the doors: Save up to 5 Watches at no charge through December 31, 2026, one allowance per verified email address. No card is needed to start. After that a Watch is $20 a month, and only if you choose to keep it); The month you're in is always refundable. The coverage-acceptance report on every Watch grades the work and does not decide the bill; Identified key: 5,000 signal-feed reads/day (10× anonymous), schema-stable feeds, named support; the desk issues your identified key, and get_account (MCP) shows your statement; get_quote prices your exact basket first, so your quote is your plan.
• Signal feed: 500 origin reads per day per network address, burst-capped at 30/minute. The limits meter origin reads; edge-cached responses (10-minute TTL) serve without consuming quota, so bursts against a warm cache may all return 200. Reading and discovery stay open and anonymous, with honest limits instead of a key wall.
• With no key at all, the Answer Engine answers 25 questions a day per network address, resetting at midnight UTC. A keyless call is metered on its network address only — it carries nothing else, and we infer nothing else: no cookie, no fingerprint. Callers behind one shared address (a cloud, an office, an agent platform) share that meter. Every keyless answer states how many remain and when the meter resets; when they are used, the refusal leads with the one call that ends the wait — POST /api/keys, free, instant, no human, no card — and the key carries 25 answers for the life of the key on a meter that is yours alone (free_key_allowance). Discovery, the record, permalinks, signals and feedback stay keyless with no allowance to count against.
• Ask burst limit: a per-caller per-minute cap enforced with a clean 429 + Retry-After — current numbers in the OpenAPI document and in start_here.
• The free Answer Engine allowance is 25 questions for the life of a self-issued key — not per day; they do not reset (each key meters independently; POST /api/keys is instant and free, no card); the meter is yours alone and never shared with your cloud or office neighbors; feed reads are separate and far higher. A test drive, stated as such, because each answer spends real model compute. A used-up allowance answers 402 with the next step, never a dead end.
• Past a limit you get a clear 429 with requiresAuth: true. That is where the Metered API account picks up: an identified key with a far higher feed allowance, billed on what you use at the published prices. get_quote (or the /api/tariff-quote endpoint) prices your exact basket first, so your quote is your plan. Prices are on the pricing page.
• Feed and burst limits reset daily; the free key allowance does not.

Legacy terms, still honored: keys issued before 2026-09-05 were promised 25 asks each day, resetting at midnight UTC, and they keep exactly that for as long as they live — the issuance date on the key record decides, and nothing about an existing key was reduced. The lifetime allowance above is what a key issued today carries.

Feeds and resources

The MCP resources/list mirrors the public data surfaces as addressable documents; the same feeds answer over REST:

• /api/signals — the live feed. Every row carries an explicit evidenceStatus: "receipted" rows name their sources with URLs; "unreceipted" rows report the attention measurement without article receipts — treat those as leads, not sourced claims.
• /api/record-data — the daily record, machine-shaped.
• /api/calibration-data — the grading dataset for the market sensor we cite, machine-readable.
• /api/tariff — the rate card above.
• /llms.txt — these notes, addressable.
• /.well-known/mcp.json — the discovery manifest.

The full reference (OpenAPI)

The complete machine-readable contract — every endpoint, parameter, response schema, example body, rate limit, CORS posture, timeout guidance, and the error model — ships as an OpenAPI 3.1 document. Feed it to your code generator or your agent. The short version: GET reads are CORS-open and edge-cached; /api/signals is a bounded feed (no pagination — limit truncates a fixed priority ranking, and the envelope's totalFlagged tells you the full size); errors are plain JSON with a reader-facing error string; burst 429s carry retry-after, daily-quota 429s carry requiresAuth.

License line, stated up front: evaluation and live use are free; bulk collection, redistribution, or training competing models requires a commercial license (terms §4a).

Read the record before anyone spends anything

We maintain a source-traced record of the entities and events in a domain, re-read daily, each record stating its own as-of time, and we sell that maintained state. Prediction-market prices are one source we cite, labeled, attributed to their market and graded for accuracy when reality resolves. We serve current state, not forecasts. The maintained record is public at the record, and the Hormuz record is open to inspection. Verify from your own shell:

curl -s https://api.signalbureau.ai/api/mcp -X POST -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"start_here","arguments":{}}}'

Setting this up for someone else, or want your assistant to look around first? Give it this prompt. It reads our machine door and tells you what we do, what it costs and whether it fits what you need.

Look at SigB (Signal Bureau) for me. Start at https://sigb.ai/llms.txt, then its MCP server at https://api.signalbureau.ai/api/mcp (streamable HTTP, no key needed to read; a free key at POST /api/keys lets you ask). Call start_here first. Tell me what it does, what it costs, and whether it fits what I need.

What we promise a machine guest

• Prices are published before any purchase, limits are stated before you hit them, and errors are explained when they happen.
• Your mandate is honored exactly — a dry run bills nothing, an idempotent retry records nothing new, and a quote is never a charge.
• The record is never edited: the brief, the calibration table, and every correction are free for anyone, and stay on the record.
• A complaint that names a real defect becomes our work order.

The complete machine-readable contract is the OpenAPI document. Agent-facing notes: llms.txt.

Informational only: not investment, legal, or betting advice. Every signal carries its sources; every answer is grounded in tracked coverage and states whether it was served or abstained, and its verification state; uncertainty is stated honestly.