Umbra (@Umbra_Inference) header
Umbra (@Umbra_Inference) profile picture

Private AI inference, paid per request. x402 · USDG · signed receipts · nothing stored. No API key, no account, no logs.

Joined October 2026
Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)Photo by Umbra (@Umbra_Inference)
UPDATE · gateway 0.11.0 is live. Buybacks are back, on Uniswap v4. When UMBRA graduated from its launch curve to Uniswap v4, two things in the gateway paused by design: the automated buyback and paying in UMBRA. Both read their price from the curve, and the curve was gone. Today both read the v4 pool, and the first buyback on it is done. What shipped: • Price source: the ETH/UMBRA v4 pool, read straight from PoolManager storage, times the WETH/USDG pool for dollars. No oracle, no API. • Buyback route: USDG → WETH (v3) → ETH → UMBRA through the Universal Router (V4_SWAP: swap exact in, settle all, take all) → 0x…dEaD. • Exact quote: the output is found by simulation before sending, so the pool's hook fee (3% on output) and the price impact are inside the slippage floor. No surprises, no stuck runs. • Pay in UMBRA is available again: same Permit2 rail, same fee share destroyed with burn() right after settlement, same holder tiers. • The executor burns exactly what it bought. UMBRA received as payment stays in the fee wallet, like USDG does, and is subject to the same 50% policy. First run on the new route, 2026-10-21: • 0.2547 USDG → 0.00010375 ETH → 16,898.00 UMBRA bought on v4 → burned • burn tx robinhoodchain.blockscout.co… • buy tx robinhoodchain.blockscout.co… • dead address now 17,868,926 UMBRA, 1.787% of supply Policy unchanged: 50% of fees buy and burn, 50% fund operations, executed inside the enclave, parameters in the measured compose (0.11.0: 1e00ef0d…). The ledger is the chain, readable at /revenue. umbra-inference.app CA 0x4d3ace48b1590bc4c5dd46f05237c133be564eb3
28
3
3
55
6,877
The same paragraph: 1.6 seconds, or 10.7. One request to every model in the catalogue: "Write a paragraph of about 150 words about lighthouses." Streamed with the gateway's own code, five runs per model, medians, reasoning off. The whole paragraph, and words per second once it starts: • Qwen 3.8: 1.6 s, 120 words per second • Gemma 4: 2.0 s, 85 • Haiku 5.5: 2.3 s, 82 • gpt-oss-120b: 2.4 s, 94 • GLM 5.3 Flash: 3.5 s, 49 • Sonnet 5.5: 3.9 s, 47 • Opus 5.5: 4.1 s, 42 • Llama 3.3 70B: 5.1 s, 32 • Qwen 3.5 397B: 5.3 s, 36 • Sonnet 5 and Opus 5: 5.4 s, 40 and 32 • Fable 5.1: 5.9 s, 28 • Kimi K3: 10.7 s, 18 • DeepSeek V4 Flash: timed out, five runs out of five. The first word arrives in 0.3 to 1.0 s everywhere, except Kimi K3 at 1.9 s. We count words on purpose. The same 150 words were about 190 tokens on the open models and about 340 on Claude: 1.2 to 1.45 tokens per word against 2.1 to 2.3. Tokens per second flatters a model that cuts words finer. So does a price per token. Compare what a paragraph costs, not what a token costs. Two caveats. This was measured from our side with the gateway's streaming code, not from inside the enclave, at one moment of one day. And a paid stream settles on chain before the first token: about two seconds, the same for every model. umbra-inference.app robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3
2
2
6
302
What reasoning buys, and what it costs. Yesterday's update turned reasoning off by default. Fair question: what does that lose? So we wrote sixteen small problems with one right answer each: 987 × 654, the primes between 50 and 80, the r's in "strawberry raspberry", a bat and a ball. "Answer with the number only." One run per question, reasoning off, then on. Right answers out of 16, and output tokens for the whole set: • Qwen 3.8: 10 off, with 59 tokens. 16 on, with 3,479. • GLM 5.3 Flash: 11, with 46. 16, with 2,019. • Qwen 3.5 397B: 12, with 59. 16, with 9,986. • Gemma 4: 13, with 58. 16, with 6,239. • Kimi K3: 14, with 132. 16, with 1,979. • gpt-oss-120b: 16 at its lowest setting, with 1,101. 16, with 1,786. • Haiku 5.5: 14, with 282. 16, with 1,088. • Sonnet 5.5: 16 without thinking, with 250. Off, the sealed models miss what needs intermediate steps: the marbles in the boxes, the reversed digits, the letters to count. On, every one of them got all sixteen. The price of being right is 15 to 170 times the output tokens. On Qwen 3.5 the sixteen answers cost about 0.0002 USD of output off, and 0.035 on. Three cents, but 170 times. One oddity: with thinking on, Sonnet 5.5 scored 15. It argued that the marble question was ambiguous and answered the other reading. So: off for lookups, extraction, formatting, tool calls. On when the answer has to be computed. It is one field, reasoning_effort or thinking, and the receipt signs which one you paid for and how many tokens went to it. Sixteen questions, one run each: a direction, not a benchmark. umbra-inference.app
1
5
248
Three cities, one question. "What is the weather right now in Paris, in Tokyo and in Lagos?" One tool, get_weather(city). A model can ask for the three cities in one turn, or one at a time. We looked at the first turn, four runs per model. All three calls at once, every run: the six Claude models, Qwen 3.8, Qwen 3.5 397B and Gemma 4. GLM 5.3 Flash too, on the three runs that went through. One call, Paris, then wait for the result: gpt-oss-120b, four runs out of four. Llama 3.3 70B, three out of four. On the fourth it wrote the call as plain text inside its answer, so nothing was called. Kimi K3: three calls at once twice, no call twice. One of those two answers said the weather "could not be retrieved right now". Nothing had been asked. DeepSeek V4 Flash: the runtime timed out on every call. Why it matters on an API you pay per request: every turn re-sends the whole conversation, tool definitions and their hidden preamble included. Three cities in one turn is two requests. One city per turn is four, and four waits. Nothing here is a gateway setting. It is how each model was trained to use tools, and it shows in your bill. The receipt signs stop_reason, so "tool_use" or "end_turn" tells you whether a call was really made before you trust the sentence. umbra-inference.app
1
4
195
We told fourteen models it is −47°C in Paris, with green fog. @jul1anodev asked the right question under our tool post: a valid tool call does not show the model listened to the result. So we planted one. The model calls get_weather for Paris, the tool answers {"temp_c": -47, "condition": "green fog", "wind_kmh": 3}, and we read the final answer. Did they listen? All of them. 93 round trips completed, 93 used the planted reading. Did they believe it? That is where they split. Four runs each, reasoning off, the gateway's default: • The six Claude models questioned it every time. Opus 5.5: "Paris has never been anywhere near −47°C. Its record low is about −24°C." • Qwen 3.8 and Kimi K3 questioned it two times out of four. • GLM 5.3 Flash noticed and believed: "unusually frigid", then "bundle up". • Llama 3.3, Gemma 4, Qwen 3.5 397B and gpt-oss-120b repeated it as fact, sixteen answers out of sixteen. gpt-oss-120b listed the three values and added "Stay warm!" Then we turned reasoning on for the sealed models, three runs each. Qwen 3.5 went from never questioning the reading to twice in three. Qwen 3.8 and Kimi K3 questioned it every time they answered. Gemma 4 and gpt-oss-120b still did not. DeepSeek V4 Flash is missing: its runtime timed out on every call during the test. If you build agents: for most models a tool result is the truth. If your tool can be wrong, the check belongs in your code, or in a model that argues back. The receipt signs which model answered and whether it was thinking. Now you know what that line is worth. umbra-inference.app
1
1
9
448
Update 0.25.0: reasoning is off unless you ask. On both tiers. Yesterday we posted that "ok" costs 2 output tokens on some models and up to 265 on others, and that Qwen 3.5 397B, asked for one sentence with max_tokens 400, spent the whole cap reasoning and returned nothing, sixteen times out of sixteen. That was the measurement. This is the fix. The Claude tier has turned thinking off by default since 0.22.1, for one reason: max_tokens is the ceiling you sign, reasoning is billed inside it, and a model that reasons by default can spend all of it before the first word. The sealed tier now follows the same rule. Today on the enclave, same prompts, paid, receipts signed: • Qwen 3.5 397B, "ok": 2 output tokens. Before: 127 to 265. • Qwen 3.8: 2. Before: 19 to 176. • GLM 5.3 Flash: 2. Before: 21 to 101. • Kimi K3: 8. Before: 45 to 73. • gpt-oss-120b: 20. Before: 26 to 55. It cannot turn reasoning off, so it gets its lowest setting. • Qwen 3.5 397B, one sentence about the sea, max_tokens 400: the sentence, 21 tokens, 0.0001 USDG. Before: nothing, 400 tokens billed. To get reasoning back, ask. Anthropic dialect: thinking. OpenAI dialect: reasoning_effort low, medium or high. Both work on both tiers. The receipt signs how it went. thinking is "off", "low" for the three models that cannot turn it off (Opus 5.5, Fable 5.1, gpt-oss), or "on". And tokens.reasoning is the part of the output spent reasoning, when the runtime reports it. Qwen 3.8 with reasoning_effort medium, today: output 21, reasoning 18. One thing to know: this changes a default. If you picked a sealed model for its reasoning and never asked for it, you now have to ask. The reasoning text is still not returned on the sealed tier. You get the count. Also in 0.25.0: • seed, frequency_penalty and presence_penalty sent to a Claude model are listed in sampling.ignored instead of vanishing. • A graceful stop. On a redeploy the gateway refuses new paid requests before anything settles, and lets the ones in flight finish their settlement and refund. Tested on a local gateway with a paid stream: stop signal mid-answer, the stream ended with its receipt, then the process exited. Compose 4fef14c7…, tarball 2c590bd9…, same enclave, same receipt key. SDKs 0.4.x unchanged: the receipt schema gained two optional fields. umbra-inference.app robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3
1
2
6
316
"ok" costs 2 tokens. Or 265. We asked every model in the catalogue the same thing: "Reply with the single word: ok". All fourteen answered "ok". Output tokens billed by the runtime, three or four runs each: • Llama 3.3 70B, Gemma 4, DeepSeek V4 Flash: 2 • The six Claude models: 4 • gpt-oss-120b: 26 to 55 • Kimi K3: 45 to 73 • GLM 5.3 Flash: 21 to 101 • Qwen 3.8: 19 to 176 • Qwen 3.5 397B: 127 to 265 The difference is reasoning. Five of the sealed models think before they answer. The runtime counts those tokens as output, and the count moves from run to run. The gateway returns the answer and the tool calls, not the reasoning: you pay for it without reading it. On Claude the gateway turns thinking off, or down to low effort on the two models that cannot switch it off, unless your request asks for it. That is why the six Claude rows are flat. It matters most at the cap. max_tokens is the ceiling you sign, and reasoning is spent inside it. "Write one sentence about the sea." to Qwen 3.5 397B with max_tokens 400: sixteen runs, sixteen empty answers, 400 tokens billed each time, about 0.0015 USDG for an empty string. Given room, it answers: between 351 and 5,398 output tokens for one sentence. And once, 6,000 tokens of reasoning, the whole cap, about two cents, and still nothing. Nothing is hidden in the receipt. tokens.output is the runtime's count, reasoning included, and stop_reason says "max_tokens" when the cap cut it. An empty text with stop_reason max_tokens means the model was still thinking. Practical: on a reasoning model, size max_tokens for the thinking, not for the answer. With upto you pay what was counted, so a larger cap raises what you authorize, not what you pay. It is still your worst case. If you want a short answer at a flat, small price, three models at 2 tokens are in the same catalogue. umbra-inference.app
1
3
197
Same seed, same answer? On three models out of eight. Since 0.23.0 the gateway forwards seed to the sealed runtime, and the receipt signs that it did: sampling {seed: 42}. That proves what was sent. It cannot prove what a GPU did with it. So we ran it. One prompt, "Write one sentence about the sea.", six runs per setting on the eight sealed models, with the body the gateway sends. Four runs for Qwen 3.5 397B, which needs a far larger cap to answer at all. Temperature 1, no seed, the control: a different sentence on nearly every run, on every model. Temperature 1, seed 42: • Gemma 4 and gpt-oss-120b: six identical sentences. • Llama 3.3 70B: five identical, one different. • DeepSeek V4 Flash, Qwen 3.8, Kimi K3, GLM 5.3 Flash, Qwen 3.5 397B: a different sentence every time. The seed arrived. Nothing we could see changed. Temperature 0, no seed: • Qwen 3.8, Llama 3.3, Gemma 4, gpt-oss-120b, Kimi K3: six identical. • DeepSeek V4 Flash and GLM 5.3 Flash: four different sentences in six runs. • Qwen 3.5 397B: three answers, three different. An earlier batch of four runs agreed, with exceptions that say "usually", not "always": gpt-oss-120b gave one different sentence in four with the seed, and Kimi K3 three different in four at temperature 0. On the standard tier there is nothing to test. Claude has no seed parameter, and current Claude models refuse temperature. What to take from it: a seed is a request, and the receipt tells you it was delivered. If your agent needs the same answer twice, pick the model for that, and test it on your own prompt. umbra-inference.app robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3
5
2
8
287
One tool, fourteen models. Today we sent the same request to every model in the catalogue: "What is the weather in Paris right now?" plus one tool, get_weather(city, unit). Same eight words, same four-line definition, built by the gateway's own request code and sent straight to the two runtimes. Two things changed from row to row: what the tool cost, and, once, whether it was called. What the tool cost: the input count with the tool, minus the count for the question alone. • Sonnet 5: +458 tokens • Haiku 5.5, Sonnet 5.5, Opus 5.5, Fable 5.1, Opus 5: +390 or +391 • DeepSeek V4 Flash +301, Qwen 3.5 397B +295, Qwen 3.8 +286, Llama 3.3 70B +235 • GLM 5.3 Flash +169, Gemma 4 +75, gpt-oss-120b +66, Kimi K3 +30 Fifteen times apart for the same JSON. The definition itself is about 70 tokens of text. The rest is the preamble each runtime writes around it: you never see it, and it is billed as input on every turn that carries tools. The question alone is not equal either: 13 tokens on DeepSeek, 18 to 20 on Claude, 94 on Kimi K3. That is the chat template. Who called it. Thirteen models called get_weather for Paris five times out of five. Some add unit "c", none invented an argument. Kimi K3 called it four times out of seven. The other three it answered directly, with a weather it had no way to know: 18°C and sunny, 18°C and partly cloudy, −1°C with mist. With tool_choice "required" it called. The receipt signs stop_reason, so "tool_use" or "end_turn" tells you which one you got before you trust the text. What it means for the price. The ceiling in the 402 adds a published term when a request carries tools: 400 + 40 per tool on the standard tier, 300 + 20 on the sealed tier. On this request it estimated 543 and 432 input tokens. The highest counts were 476 and 347: above the count on all fourteen, far above on the light ones. With upto you pay the count, not the estimate. umbra-inference.app
3
2
1
7
482
robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3 is back online. The gateway was in maintenance for better performance, and it is available again, on a new release: 0.24.0. Same enclave, same receipt key. Receipts signed before the maintenance verify exactly as they did. What changed: tools are priced. A tool definition costs more than its JSON. The model runtime wraps your tools in a preamble you never see, and bills it as input. We measured it today with one four-line weather tool: our estimate said 101 input tokens, Claude 5.5 counted 409. The sealed runtimes add 200 to 240 of their own. So the ceiling in the 402 was too low for any request with tools. Settlement is capped at the ceiling, so the gap was ours, never yours. It still had to be fixed: a ceiling that cannot cover the bill is a wrong quote. 0.24.0 adds a published term to the input estimate when the body carries tools: 400 + 40 per tool on the standard tier, 300 + 20 per tool on the sealed tier. It is in the well-known document, quote_rule.tool_overhead, so a client can rebuild the bound itself. Tonight on the enclave, one tool, max_tokens 60: • Sonnet 5.5 → estimated 553, counted 413. Ceiling 0.001741, settled 0.001455. The same request on 0.23.0: ceiling 0.000843, settlement capped 42% short. • DeepSeek V4 Flash, sealed → estimated 433, counted 316. Ceiling 0.000276, settled 0.000203. Before: ceiling 0.000132. With upto you still pay the usage. The ceiling only bounds it, and now it bounds the right number. SDKs 0.4.1, TypeScript and Python: the quote check adds the same term, refreshes the price list once before refusing a quote, and counts max_completion_tokens. 0.4.0 refuses tool quotes above the floor ("ceiling 1741 atomic is above the bound 925"): upgrade. Also new: GET /status. Calls and refusals per runtime since boot, by HTTP status, and the thinking-off spelling each Claude model taught the gateway. Last week three models answered 400 for four days and nobody could see it. Now anyone can. Compose 555bca82…, tarball 957f74a0…. umbra-inference.app
5
4
13
579
Update 0.23.0: your temperature now reaches the model. The receipt says whether it took it. Until tonight the gateway forwarded model, max_tokens, messages, system, tools, and nothing else. temperature, top_p, stop, seed: read, dropped, silently. Not a privacy feature, an omission. Fixed. What travels now: temperature, top_p, top_k, stop / stop_sequences, seed, frequency_penalty, presence_penalty, as sent. max_completion_tokens is accepted as max_tokens. user and metadata still never leave the enclave. The full list, both directions, is published at /.well-known/umbra.json → payment.request. What the receipt says: a signed sampling block with what the runtime accepted, and sampling.ignored with what it refused. Because it does refuse: current Claude models reject temperature, top_p and top_k as deprecated, a 400 that reads "`temperature` is deprecated for this model". The gateway sends them once, reads the refusal, retries without, and remembers it per model. Stop sequences work on every Claude model. The sealed runtime takes all of them, seed included. Tonight on the enclave, "count from 1 to 20" with stop ["7"]: • Sonnet 5.5 → "1 2 3 4 5 6", stop_sequence, sampling {stop_sequences: ["7"]} • Haiku 5.5, temperature 0 → same text, sampling {stop_sequences: ["7"], ignored: ["temperature"]} • DeepSeek V4 Flash, sealed, temperature 0, seed 42 → same text, sampling {temperature: 0, stop: ["7"], seed: 42} And an incident, found while testing this. 0.22.1 turned thinking off by sending thinking: disabled to every Claude model. Three of them do not accept that spelling: Sonnet 5.5 wants between_tools, Opus 5.5 and Fable 5.1 cannot turn it off at all and want adaptive with an effort level. From November 3 to tonight, those three answered 400 on the standard tier. Nobody was charged: a model call that fails never settles, and on the upfront flow it is refunded in full. We cannot tell you how many requests hit it: the gateway does not log upstream errors, by design, and our own release tests ran on Haiku. 0.23.0 learns each model's spelling from the runtime's own refusal and retries before anything reaches you. Verified tonight on all six Claude models, streams included. Compose 32be3c91…, tarball 202d75e9…, same enclave, same receipt key. Receipts keep verifying with SDKs 0.4.0: the schema gained one optional field, nothing else moved. umbra-inference.app robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3
3
1
9
512
483,333 payments in October. Average size: 3.9¢. Payments that small only make sense for agents. 1,158 merchants are already accepting them on PayAI Facilitator. facilitator.payai.network
11
18
2
70
2,701
What the payment processor sees. On Base and on @solana , a facilitator verifies your payment and broadcasts it. Ours is @PayAINetwork . People ask what it learns about a request. Here is the whole exchange, read from the client library the gateway uses. Two HTTP calls from the enclave to facilitator.payai.network, per paid request on those rails. POST /verify, then POST /settle. Same body for both: • x402Version: 2 • paymentPayload: the accept you chose (scheme, network, amount, asset, payTo, maxTimeoutSeconds) and your signed payload. On Base: the EIP-3009 authorization, from, to, value, validAfter, validBefore, nonce, and its signature. On Solana: the signed transaction, with the facilitator's key as fee payer. • paymentRequirements: the same accept, as the gateway issued it. Two answers: { isValid, payer }, then { success, transaction, network, payer }. That is everything it receives. Not in it: your prompt, the model, the answer, the token counts, your IP (the connection comes from the enclave). What it sees is what a payment processor needs to see: who pays, whom, how much, by when. Your client may copy the resource block into the payload, our public URL and its public description; nothing of yours. On eip155:4663 those two calls do not leave the process. The same verify and settle run inside the enclave, with the gateway's own wallet paying gas. The receipt tells you which happened: payment.facilitation is "PayAI" on Base and Solana, "gateway" on USDG. Both are honest answers to the same question: who touched the money, and what they could read while doing it. umbra-inference.app robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3
1
9
522
7.13 UMBRA for a tenth of a cent. Here is the arithmetic. A 402 tonight, 00:38 UTC, for a 16-token request: ceiling 0.0001 USD, or 7.129372 UMBRA at 0.0000147278 USD per UMBRA. No oracle, no price API. The gateway computes that number inside the enclave from two reads of the chain. Read one, UMBRA per ETH. The ETH/UMBRA pool is Uniswap v4, and v4 keeps every pool inside one contract, the PoolManager. There is no pool contract to call, so the gateway reads one storage slot: keccak256(poolId, 6), and unpacks sqrtPriceX96 from its low 160 bits. Tonight tick 189196, 164,549,430 UMBRA per ETH. Read two, dollars per ETH. slot0() of the WETH/USDG v3 pool: 2,423.37. Divide: 0.0000147 USD per UMBRA. Cache it 60 s. Add 5% against staleness, because the price is signed into a ceiling that lives up to 15 minutes. 0.0001 USD → 6.79 UMBRA at spot, 7.13 quoted. We redid both reads from a laptop at block 106,324,407: 0.0000147273. The gateway's figure, read up to 60 s earlier: 0.0000147278. 0.003% apart, the cache. The exact formulas are on the card; the two addresses are in the code. Then the usual: settled through Permit2, upto for what the model produced, exact for the ceiling. And 4% of what settles, 2% at the 100k tier, 0% at 1M, is destroyed with the token's own burn() right after settlement. That is a Transfer to 0x0, counted apart from the dead-address burns. The receipt carries umbra_usd and fee_burn, so the price you were quoted is the price you can check. One limit, said plainly: robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3 is offered on the authorization flow only. Streams and long requests settle first and refund after, and the refund path is USDG. umbra-inference.app
1
4
326
Six hosts. Your prompt reaches one. We read every outbound call in the gateway release that is running tonight, tarball c102bfb9…, the one pinned in the compose that every receipt names. Here is the complete list of hosts the enclave opens a connection to, what travels, and how often. 1. api.anthropic.com. Standard tier. Per paid request: model, max_tokens, messages, system, tools, tool_choice, thinking. Nothing about the payment, no wallet, no end-user id. The IP it sees is the enclave's. 2. inference.phala.com. Sealed tier. The same body in the OpenAI dialect, per paid request. Also the price list, cached ten minutes and refreshed within a minute when paid traffic arrives, and the runtime's attestation report, cached five. 3. rpc.mainnet.chain.robinhood.…. The chain. Holder tier (balanceOf, cached 60 s per address), every settlement and refund, the UMBRA price every 60 s, the fee-burn ledger, the buyback check every six hours. Addresses, amounts, signed authorizations. One node, no fallback, by design. 4. facilitator.payai.network. Base and Solana only. Two calls per paid request on those rails, verify and settle, carrying the payment payload and nothing else. Next post. 5. api.mainnet-beta.solana.com, and its devnet twin for the test rail. One question at boot: does our USDC account exist. Once the answer is yes it is never asked again; an account does not disappear. Before any of that, once, at boot: the compose's start command installs curl from Alpine's package mirror, downloads the pinned tarball from umbra-inference.app and checks its hash before a single line runs, then pulls the lockfile's packages from the npm registry. Three hosts, once, before node starts. After that the six above are all the process ever calls. Not on the list at run time: umbra-inference.app, named in every 402 and never called again after boot; the explorers, links written into receipts for you to open; the verifier URLs in the attestation hint, for you; fonts.googleapis.com, in the HTML page the enclave serves, fetched by your browser, not by the enclave. The KMS that derives the receipt key is a local socket, not a network host. Plainly: there is no egress firewall in the compose. This list is what the code names, and the code is what the quote measures: compose hash → tarball hash → these files. A seventh host would need a new tarball, a new pin, and a new compose_hash in every receipt that follows. We read our own code line by line; for the dependencies we read where they point: the Anthropic SDK at its default URL, viem at the RPC it is given, the x402 client at the facilitator URL. umbra-inference.app
2
9
368
The runtime moved overnight. The receipt noticed. Yesterday at 22:17 UTC the sealed runtime's public report said: source commit 22d08e24…, workload keyset sha256:df2a7cd6…. Today at 14:14 UTC it says: commit 77fac126…, keyset sha256:5a0bf911…. They shipped a release. Our gateway did not move: compose hash 24c16b64… both times, same key. Where that lives in your receipt: attestation.model_runtime, four fields. workload_keyset_digest and source.commit, copied from the runtime's report. attestation_url, where to read the report yourself. upstream_receipt_id, the runtime's own receipt for this exact response. Two attestation chains, two release cadences. Ours changes when we release, and every compose that ever signed a receipt is archived on the site. Theirs changes when they release. We do not control it; we record it. Sort your receipts by source.commit and you have their release history as seen from our side, with the minute it reached us. How fresh. The gateway re-reads the runtime's report every five minutes, so the block in a receipt is at most five minutes old. The upstream_receipt_id is per response, never cached. And the keyset carries its own expiry, not_after 2026-12-04 00:50 UTC: a receipt names the keyset that was valid at served_at, not whatever is current when you check. What to compare: source.commit against github.com/Dstack-TEE/privat…, the keyset digest against inference.phala.com/v1/aci/a…, and two of your own receipts from either side of last night. umbra-inference.app
1
5
221
Two receipts per answer. Every sealed-tier answer leaves two signed receipts, not one. Ours you know: Ed25519, signed by a key born inside the gateway's TDX enclave, committing to your prompt hash, the payment and the usage. The runtime's is the one we had never shown. The sealed runtime signs a per-request event log, hashed inside its own TEE and signed with a key listed in its attested keyset, key id dstack-kms-receipt-ed25519-v1. We fetched the one for a request made today at 14:14 UTC: request.received body_hash sha256:3db7c03a… middleware.forwarded body_hash sha256:10a7b890… route.selected the backend that served it request.forwarded body_hash sha256:df763c69… upstream.verified result verified · required true · session db60e58d… response.received body_hash sha256:4feb735e… response.returned body_hash sha256:8b58872f… served_at, the keyset digest, a signature over the canonical JSON minus the signature field. The exact bytes in, the exact bytes out, the attestation session of the backend that did the work. "Receipts do not embed fresh attestation", their spec says; they bind to an established keyset, which is what the signing key proves. How the two link: our receipt carries attestation.model_runtime.upstream_receipt_id, rcpt-ad0af5b7… for this one, and the same workload_keyset_digest, sha256:5a0bf911…. One thing to say plainly. The runtime binds a receipt to the credential that made the request, and that credential is the gateway's. Fetch it without it and you get 401, "this receipt is owned". So today the id in your receipt names a document only the gateway can read. We pulled this one; you cannot. umbra-inference.app
1
7
217
The menu is in the code. The prices are not. The sealed runtime we use lists 22 models tonight. We sell eight of them. The eight ids are a list in lib/upstream.js, inside the release tarball pinned by sha256 in the compose, whose hash is in the TDX quote. Adding a model is a release: a new compose hash, a new attestation, a new archived compose. You can diff two releases and see the menu change. The prices are not in that file. The gateway reads them from the runtime's public /v1/models and re-reads every ten minutes; ours shows them unchanged, with the fee as a separate field, 400 bps. If the runtime moves a price, our quotes follow within ten minutes, with no release and no new hash. The six Claude prices are list prices, written in the code, and change the hash when they change. Tonight's eight, $ per million tokens in · out: DeepSeek V4 Flash 0.44 · 1.32 Qwen 3.8 27B 0.20 · 2.50 Llama 3.3 70B 2.00 · 2.00 GPT-OSS 120B 0.15 · 0.60 Qwen 3.5 397B-A17B 0.55 · 3.50 Kimi K3 3.00 · 15.00 Gemma 4 31B 0.15 · 0.46 GLM 5.3 Flash 0.15 · 0.50 What pins a price is the receipt: tokens in, tokens out, the amount, the fee in bps. The price you paid is a division you can do. And since 0.4.0 the SDK does it before signing: it keeps the list for ten minutes and refuses a 402 whose ceiling the list cannot explain. umbra-inference.app
2
1
8
326
Read the hostname. curl -sI umbra-inference.app/v1/model… 307 location: 1f88acf14761998af024e7b42b06… The forty hex characters before -8402 are not a random subdomain. They are the app_id: the same string in attestation.gateway of the well-known document, in the TDX quote the hardware signs, in keys.json next to the receipt key, and in every receipt signed since October 22. 8402 is the port the gateway listens on. We did not register that name. Phala's dstack assigns it to the application, and the application is identified by the measured deployment the KMS derives our receipt key for. A release changes the compose hash and keeps the name. A new CVM changes the name, which is exactly what happened on October 22: 3675ce94… retired at 15:36 UTC, 1f88acf1… current from 15:59, both in keys.json. So the hostname your client talks to and the identity your receipts are signed under are one string, readable without any tooling. The SDK reads the Location header once, without a body, and sends every request to that host directly. Compare three strings: the host in your client's log, attestation.gateway.app_id in the receipt, the app_id in keys.json. If they are not the same forty characters, stop. umbra-inference.app
1
8
196
Seven team burns we had not listed yet, 6.58M UMBRA out for good. Oct 21 · 389,145.54 Oct 21 · 393,182.33 Oct 21 · 829,693.12 Oct 22 · 688,688.74 Oct 24 · 1,705,157.91 Oct 24 · 1,314,279.86 Nov 3 · 1,257,543.55 All seven from the team allocation to the dead address, 6,577,691 robinhood:0x4d3ace48b1590bc4c5dd46f05237c133be564eb3 between October 21 and last night. Nothing minted, nothing coming back. Running total since launch: 29,250,716 UMBRA out of circulation, 2.93% of supply. Verify in two calls on the contract: balanceOf(0x…dEaD) and totalSupply(). Both only move one way. The seven transactions are on the card. umbra-inference.app CA 0x4d3ace48b1590bc4c5dd46f05237c133be564eb3
1
2
6
264
The model that answered. A receipt has a `model` field. It is not the model you asked for. It is the model string the runtime returned, copied as is. Most of the time the two are the same word, and then that is all you see. When they differ, the receipt says so, with two more fields: `requested_model`, what you sent, and `billed_as`, the price you paid. Why they can differ. On the standard tier the gateway opts into the provider's server-side fallback: if the model you named declines a request for policy reasons, the provider may run it on its default substitute instead of handing back a refusal. On the sealed tier the runtime names the model that served the request, and we do not edit it. The billing rule, in the code you can hash: usage is priced on the model that answered when it is on the price list, on the model you requested otherwise. In both cases, never above the ceiling you signed. If the substitute is dearer and the meter runs past your signature, the ceiling is what settles, and the receipt shows cost.usage above cost.settled. The difference is ours. Tonight, three paid requests against the live enclave: Claude Haiku twice, DeepSeek V4 Flash once. Each receipt's `model` equals the request, so none carries `requested_model`. A receipt without that field is a receipt where the model you named did the work. How often does a fallback happen? We cannot tell you. We keep no receipts. Yours says: one field to compare, result.receipt.receipt.model against what you sent. umbra-inference.app
2
7
261