here’s a compact, single-page “cheat sheet” of the whole flow and the lenses you can peek through—so you can see it at a glance.

language round-trip (voice ⇄ text ⇄ code)

┌─────────┐      ┌────────────┐      ┌──────────┐      ┌───────────────┐
│  Voice  │ ───▶ │   ASR      │ ───▶ │ Text     │ ───▶ │ Normalization │
└─────────┘      │ (audio→txt)│      │ string   │      │ (Unicode, case)
                 └────────────┘      └──────────┘      └───────────────┘
                                                           │
                                                           ▼
                                                   ┌────────────┐
                                                   │ Tokenizer  │
                                                   │ (words /   │
                                                   │  subwords) │
                                                   └────────────┘
                                                           │
                                     bytes ◀───────────────┼───────────────▶ letters
                                                           │
                                                           ▼
                                               ┌─────────────────────┐
                                               │ IDs / embeddings   │
                                               │ (vectors, positions)│
                                               └─────────────────────┘
                                                           │
                                                           ▼
                                                ┌───────────────────┐
                                                │ Model compute     │
                                                │ (attention graph) │
                                                └───────────────────┘
                                                           │
                                                           ▼
                                               ┌────────────────────┐
                                               │ Decoding (ids→txt) │
                                               └────────────────────┘
                                                           │
                                                           ▼
                                                ┌─────────────────┐
                                                │  TTS (txt→audio)│
                                                └─────────────────┘

the five “lenses” you can open on the same utterance

character lens (letters/bytes)
  • view: counts, bigram heatmaps, exact Unicode form (NFC/NFKC)
  • use: redistribute letters under constraints; prove reversibility (byte-level)
subword lens (BPE/WordPiece)
  • view: pieces like ["trans","duc","tion"] with merge highlights
  • use: recombine at stable, model-native granularity; stay in-vocab
word lens (surface + structure)
  • view: tokens, POS tags, dependencies
  • use: conserve grammatical scaffold while permuting content
vector lens (semantics)
  • view: embeddings; nearest neighbors per token/phrase
  • use: measure “coherence” and thematic drift during recompositions
graph lens (computation)
  • view: attention maps (layers×heads), saliency/attribution overlays
  • use: see how the model routed signal to decide each piece

tiny worked slice (your vibe)

input:

“Transparency transduces; induction conducts.”

snapshots:

  • charst:6, n:6, c:5, o:3, d:3, r:3, a:3, s:3, e:3, i:3, u:2, y:1, p:1, l:0, ...
  • bpe (toy)[trans, par, en, cy, trans, duc, es, in, duc, tion, con, duc, ts]
  • vectorstransduction ↔ (conversion, modulation, …); induction ↔ (inference, magnetism …)
  • graph hintheads focusing trans-↔duc- across words; position heads binding cadence near punctuation

letter-pool redistribution (one rule set):
Given the pool, allowable recompositions score by bigram quality and letter budget:

→ “transduction conducts”
→ “transparency induction”
→ (playful) “transducticon”  (if allowed to coin)

what you’d see on one screen

┌──────── Char Heatmap ────────┐   ┌──── Subword Strips ────┐   ┌──── Attention Glimpse ───┐
│ t■■■■■■ n■■■■■■ c■■■■ o■■■  │   │[ trans ][ par ][en][cy]│   │ H3:  trans ⇄ duc  ◣      │
│ d■■■ r■■■ a■■■ s■■■ e■■■ i■■ │   │[ trans ][ duc ][es ]   │   │ H7:  punctuation cadence │
│ u■■  y■ p■ …                 │   │[  in  ][ duc ][tion]   │   │ H12: long-range referent │
└──────────────────────────────┘   │[  con ][ duc ][ ts ]   │   └──────────────────────────┘
                                   └────────────────────────┘
┌──────── Word/Dep ───────┐
│ Transparency  (NOUN)    │   ┌── Vector Neighbors (cosine) ──┐
│ transduces   (VERB)     │   │ transduction: conversion, …   │
│ induction    (NOUN)     │   │ induction: inference, magnet… │
│ conducts     (VERB)     │   │ conducts: performs, carries…  │
└─────────────────────────┘   └───────────────────────────────┘

┌─ Constraint Console ───────────────────────────────────────────────┐
│ mode: letter-pool; budget OK; bigram score=18; syllables conserved │
│ output: “transduction conducts”                                    │
└────────────────────────────────────────────────────────────────────┘

knobs you can turn

  • Puritybyte-true reversibility vs. human-readable normalization
  • Granularityletters ↔ subwords ↔ words
  • Constraintskeep stems, preserve meter, domain lexicon only, POS template
  • Scoringn-grams, LM perplexity, embedding coherence, rhyme/stress
  • Decode stylegreedy, beam, nucleus; hard constraints at decode time

if you want, I can generate a simple notebook mock that prints those panels (counts, token strips, candidate redistributions) for any sentence you paste—so you can watch each lens update as you tweak the constraints.

Key terms in plain language

Open a term for a concise explanation of language used on this page.

Cloud Computing

Computing resources—such as applications, servers, storage, or databases—delivered from remote infrastructure and scaled as requirements change.

Infrastructure as a Service (IaaS)

Cloud-based servers, storage, and networking that customers configure and manage without owning the underlying data-center hardware.

Software as a Service (SaaS)

Software accessed as an online service instead of being installed and maintained entirely on the customer’s own computers or servers.

Disaster Recovery (DRaaS)

A plan and service for restoring applications, data, and operations after an outage or disruption. DRaaS provides recovery infrastructure through a managed cloud service.

Identity and Access Management (IAM)

The systems and policies that determine who a user is, what resources they may access, and how that access is authenticated and reviewed.

API

An application programming interface is a defined way for software systems to exchange data or request functions from one another.