# Research notes — Paradigm token generator + TensorCash branding
Date of all fetches: 2026-10-17 (UTC). Tool: `curl -sL` (no browser). Time budget: ~12 shell
commands, as requested; a few counts in section 2 are the command totals.

## 1. https://www.paradigm.xyz (generative "token generator" visual)

### URLs fetched
| URL | What it gave |
|---|---|
| https://www.paradigm.xyz (home HTML, saved `research/paradigm_home.html`) | Embedded site data incl. the "visuals" manifest (kinds, titles, autoplay interval), Svelte asset list |
| https://www.paradigm.xyz/_app/immutable/entry/start.tz9T9gv8.js (saved `research/start.js`) | 118 bytes; only imports (load_css + start). No visual code here. |
| https://www.paradigm.xyz/_app/immutable/entry/app.BwlR-XVC.js (saved `research/app.js`) | App runtime (17 KB). Contains no "self-attention" string — the generative visuals are lazy-loaded in per-visual chunks I did not follow (over the 3-asset budget). |
| https://www.paradigm.xyz/_app/immutable/assets/index.Cv0XGV0l.css (saved `research/index.css`) | 573 bytes; one Svelte close-button component. Design tokens referenced: `--btn-surface-medium`, `--color-text-default`, `--blur-control` (backdrop blur), `--radius-medium`. |

### What I established (facts)
- The homepage embeds a manifest of generative "visual" pieces that rotate on the home page:
  `visualAutoplayIntervalMs: 5000`, `visualRandomOrder: false` — i.e. a carousel of animated
  pieces, one every 5 seconds.
- The kind named `self-attention` is the token-generator piece. Its exact embedded title:
  "Autoregressive generation predicts\ntoken fragments, with attention links \nshowing context
  behind each choice."
  This tells us how it looks and behaves: text **token fragments are generated one at a time
  (autoregressive)**, and **links are drawn from the new token back to earlier context tokens** —
  the classic self-attention line-drawing motion, a token-by-token emergence of text.
- Other pieces in the carousel (same visual system, same language): `prediction-treemap`
  ("Prediction Markets"), `crypto-networks` ("+ Lightning Node / □ Validator Node — Live network
  of machines participating in crypto consensus"), `erdos` ("GPT5.5 breakthrough on the Erdos
  unit distance problem"). So the house visual language = live, data-driven generative graphics
  driven by real tokens/numbers, monospace-flavoured, quiet, precise.
- Site description: "Paradigm is a frontier technology investment firm that builds and invests
  in crypto, AI, robotics…". OG image ref: 1200×675.

### Unknown (not established in the command budget — noted honestly)
- The per-visual Svelte/canvas renderer chunks were not fetched, so the exact palette, easing,
  and line style of the `self-attention` animation are inferred from the title text, not read
  from code.
- I could not read Paradigm's full palette from CSS (only fetched one small component CSS).
  Known signals only: minimal, lots of tokens like `--btn-surface-medium`, backdrop blur,
  rounded controls; Svelte single-page app, client-rendered visuals.

## 2. https://tensorcash.org (brand + idea)

### URLs fetched
| URL | Result |
|---|---|
| https://tensorcash.org (saved `research/tensorcash_home.html`, text extract `tensorcash_home.txt`) | Hero, network stats, colour system (inline SVG defs), flow story |
| https://tensorcash.org/docs (saved `tensorcash_docs.html`) | Docs index; proof pages live under `/docs/proof/…` (the bare `/docs/proof` 404s — saved `tensorcash_proof.html` shows the 404) |
| https://tensorcash.org/docs/proof/how-it-works (saved `tc_how.html` / `tc_how.txt`) | The window/256/draws/replay mechanics |
| https://tensorcash.org/docs/proof/verification (saved `tc_verify.html` / `tc_verify.txt`) | Teacher-forced replay, "block that fails counts for zero work" |
| https://tensorcash.org/_next/static/css/7d4dbec047954d0d.css (saved `tc.css`) | Font stack tokens: `"system-ui"`, variable `--font-sans:"sans","sans Fallback"` — **system sans, no bespoke typeface** |

### Brand — colours (from inline SVG defs in the home HTML, quoted values)
- Paper/cream backgrounds: `#FAF9F6`, `#F3F1EC`
- Ink text: `#1F1E1C`, `#141412`; secondary ink `#3A3834`, `#6E6961`
- The signature green ramp (light→dark): `#DCE5D7`, `#C3D5BE`, `#A9C2A4`, `#9DB898`,
  `#8DAA88`, `#6F8F6B`, `#5F7D5B`
- Warm neutrals: `#E3DFD7`, `#D2CDC4`, `#C4BFB6`
- SVG defs pair these into `main` colours `#5F7D5B`, `#9DB898`, `#A9C2A4`, `#C4BFB6`,
  `#F3F1EC` over both `bg:#1F1E1C` (dark) and `bg:#FAF9F6` / `bg:#F3F1EC` (light) —
  i.e. the brand runs on cream paper + deep moss green + ink.
- Type: `system-ui` sans (no external fonts); tone is calm, precise, explanatory — short
  declarative sentences, small numbered steps (01 Question, 02 …), monospace-friendly numbers.

### Brand — words and numbers on the front page (quoted)
- "An open network for verified AI inference, its native coin, and a financial layer built into the chain."
- "AI compute you can verify."
- "Open AI inference where useful computation secures the chain and proves the model behind every answer."
- Stats (live on page, 2026-10-17): "Block height 31,627", "253.92K proofs/s",
  "65M tok/s", "Effective difficulty 8.93M", "Holders 19,868", "Live from scan.tensorcash.org".
- "Implied tokens per second: proofs per second × 256, the tokens each proof covers. Implied by
  difficulty and proof rate, not measured throughput."
- Flow story words (quoted): "A user or application sends a question to the network." ·
  "Same label. Different model. How do you know what actually ran?" · "Honest miner" /
  "Cheating miner" · "Model Qwen3-8B" · "Scores as ranges" · **"Number from block hash"** ·
  "0.55 … 0.40 … 0.75" style ranges with "cat 40% / dog 35% / monkey 25%" → "The answer is **dog**." ·
  "Verifier sweep" · "Block accepted. Reward paid." · "Fake model detected. Block rejected."
  · **"The same work, read once as an answer and once as proof."**

### The idea — proof of inference is the proof of work (quoted from /docs/proof/)
From `/docs/proof/how-it-works`:
- "**A window** — A run of 256 tokens of generated text. Blocks are won per window."
- "A number between 0 and 1 decides which word it becomes. Normally the provider draws that
  number privately. On TensorCash it is **taken from a hash of the latest block together with
  the question and the text written so far**."
- "For every word, the provider keeps the number that was drawn and the scores of the most
  likely options. That record can travel with the answer as its proof."
- "After every 256 tokens, the window is complete. It is hashed together with the block being
  built, and the result is compared with the difficulty target. Just like on Bitcoin, the result
  has to fall below the target. If it does, the provider has found a block… If it does not, that
  window has missed, and it does not get a second try."
- "Each full window is one chance at a block. An answer of 256 tokens has one chance…"
- "**The hash of a full window is the proof of work on TensorCash. Because that window is part of
  the answer and comes with the record of its draws, the same work also serves as proof of
  inference.**"
- "An answer shorter than 256 tokens never fills a window. It can still carry a proof of which
  model produced it, but it cannot win a block…"
- "A window in which the model was almost sure of every word… is rejected, since text that
  predictable says little about which model wrote it."
- "The source is also public, so anyone can redo the draw and see whether the provider followed
  it. When the next block arrives, every window still tied to the old one can no longer win, so
  work cannot be stockpiled."

From `/docs/proof/verification`:
- "Reruns the promised model over the window and compares its scores with the recorded ones.
  A block that fails counts for zero work."
- "The verifier gives the model the question and all 256 tokens at the same time, and the GPU
  calculates the scores for every position in one pass… The whitepaper calls this a
  **teacher-forced replay**."

Not fetched: `/docs/proof/cant-be-faked`, `/docs/proof/one-gpu` (URLs seen in the docs index only).

## 3. receipt.json (real TensorCash inference receipt) — facts used in the animation
Loaded with Python `json`, never catted. Field → value:
- `model`: `Qwen/Qwen3.8-27B`; `pow.proof.model_identifier`:
  `Qwen/Qwen3.8-27B@1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0`
- `pow.proof.tick` (VDF tick): `108167168`; `pow.proof.timestamp`: `1792154187`
- sampling config: `temperature 1.0`, `top_p 1.0`, `top_k 50`, `repetition_penalty 1.0`,
  `compute_precision bf16`, `version 4`
- `pow.proof.chosen_probs` / `sampling_u` / `chosen_tokens`: 256 values each
  (e.g. token 0: chosen token `760`, p `0.5513336658`, u `0.7981989383`)
- `pow.proof.hash_hex` (window hash): `39bd4f6a73b6977ee0e04ada41b4a4fd86014c45a1e1a5a36fdadac3b8024f69`
- `pow.proof.target_hex`: `00000231ab000000000000000000000000000000000000000000000000000000`
- `pow.proof.is_solution`: `false`
- `pow.proof.block_hash_hex` (as stored, byte-reversed vs explorers):
  `466456a5f82c331b8174181b4e05580e3612ae06ebd63f5ea8a3b20ff2cb67b9`
  → byte-reversed (explorer order) = `b967cbf20fb2a3a85e3fd6eb06ae12360e58054e1b1874811b332cf8a5566446`,
  i.e. `0xb967cbf2…6446`, block **height 31536** (per the brief; the site's live counter read
  31,627 on fetch day — different moment in time).
- `token_counts`: input `5927`, output `377`, total `6304`
- `vdf_hex` present (VDF proof blob front: `030020308f038543 49ef…`).