MOSAIC LABS

EXECUTIVE SUMMARY

Mosaic Labs is a composite-intelligence research group pursuing several converging routes toward artificial general intelligence. We pair unconventional training methods with advanced reasoning architectures and spatial computation systems, with the goal of moving past the context ceilings that constrain today's models.

Rather than simply enlarging known architectures, our work aims at qualitative jumps — transformer-native language formation, geometry-based reasoning, and new training regimes that let a model invent its own compressed dialects and grow real spatial-reasoning ability.

That research is not academic. It powers the Mosaic Protocol — a launchpad for stocks not yet onchain, where the same composite intelligence prices fragmented private equity instead of language. The lab builds the engine; the protocol funds the lab. See THE MOSAIC PROTOCOL below.

CORE TECHNICAL INNOVATIONS

Semiodynamic Language Formation: our Thauten system lets models grow transformer-native languages that sit between all human tongues, using semantic compression followed by semiodynamic extrusion tuned for compute workloads — in effect training models to reason in hyper-compressed, non-human notation.

Spatial Computation Architecture: SAGE (Semantic Automaton in Geometric Embeddings) runs Q*-class spatial reasoning, enabling real-time 60+ FPS simulation, continuous dynamical reasoning, and models that plan narratives stretching hours, days, or weeks ahead.

Reworked Training Methodologies: Errloom introduces a set of unusual post-training moves — musical dynamics injected during token inference, temperature spiking, and a fully re-cast RL vocabulary where rewards act as gravity, rubrics as attractors, and environments as looms.

CORE RESEARCH PROJECTS

Our research is split across five primary development tracks, each targeting a structural limit of current AI architectures:

1. ERRLOOM: ADVANCED REINFORCEMENT LEARNING TOOLKIT

Errloom is the post-training layer. It exists because current RL pipelines are brittle glue code around a handful of scalar rewards, and that ceiling is what keeps well-trained small models rare. Errloom rebuilds the toolkit around four ideas.

• Musical Dynamics Integration — during rollout a structured periodic signal (a “score”) is injected alongside the token stream and the sampling temperature is modulated in time with it. The premise is that reasoning has cymatic structure: certain rhythms of exploration and consolidation produce steadier chains of thought than a flat temperature. Errloom treats the score as a tunable object and lets RL discover which tempos help which task classes.
• Mosaicware Programming Language (.mos) — a small declarative DSL in which a training run is written as a program: reward terms, gates, curricula and rollout topologies are first-class expressions that compose. The same .mos file that trains a model also specifies exactly how it was trained, which is what makes all weights released auditable rather than a slogan.
• Redefined RL Abstractions — the vocabulary is deliberately physical. Rewards act as gravity (a field the policy falls toward), rubrics as attractors (stable points the trajectory orbits), environments as looms (a fixed warp the policy weaves against), rollout sets as tapestries (the finished weave you inspect for defects). The metaphors carry real intuitions — restoring force, resonance, superposition — that transfer to how the optimiser behaves.
• Procedural Learning Architecture — rather than baking skills into weights, Errloom encodes learning procedures as small programs that attach to the model kernel and run at inference. A procedure is a reusable unit of “how to get better at X” that the model can call, compose and refine. This is the mechanism behind Thauten’s operator library and, downstream, behind the valuation engine improving its own estimators over time.

2. THAUTEN: DISCRETE AUTO-ENCODER + SUPER-REASONING

Current priority project. Thauten implements the semiodynamic hypothesis directly: that meaning under compression has dynamics, and a model that reasons in a compressed representation is both cheaper and more robust than one that reasons in tokens.

• Transformer-Native Language Formation — natural language is a lossy interface the model inherits from us, not the representation it would choose. Thauten rewards a model for expressing a reasoning step in the fewest bits that still reconstruct it exactly. Under that pressure the model drifts off human syntax and settles into a dense private notation — a language native to the transformer rather than to speech.
• Two-Stage Process — first, semantic compression: map the meaning of a passage to a short code in a learned intermediate representation (IR). Second, semiodynamic extrusion: unfold that code only as far as a given compute budget allows, trading fidelity for speed on demand. A cheap query gets a coarse unfolding; a hard one gets the full expansion from the same code.
• Hypercompressed Reasoning — once the IR exists, the model reasons in the compressed space without ever expanding to tokens. Each step operates on “meaning quanta” — the semantic equivalent of working directly on a zip file. Chains of thought that would run to thousands of tokens become dozens of IR operations.
• Physics of Meaning — in the IR a reasoning problem is a landscape and the answer is a path through it. Good reasoning looks less like retrieving a fact and more like water finding the low route — “a tsunami washing over rigid static structure”, flowing around hard constraints instead of colliding with them.

3. SAGE: SEMANTIC AUTOMATON IN GEOMETRIC EMBEDDING-SPACE

Artificial Imagination Architecture — a spatial-intelligence framework that resolves the binding problem by holding semantic representations on geometric grids, giving an LLM an externalization surface for its world model. This is the piece missing from real AGI — not artificial intelligence as such, but artificial imagination.

CORE ARCHITECTURE

1. HRM on a 2D grid — a Hierarchical Reasoning Model operates over a 2D grid whose cells each hold an LLM embedding. Because the cell alphabet is the embedding space itself, the grid is a universal canvas: any concept the LLM knows can be placed at a coordinate. The HRM is pre-trained on this canvas as a standalone foundation model before any language model is attached.
2. LLM integration — the grid model is not trained from scratch; it is bolted onto an existing decoder-only LLM by sharing one embedding space. The LLM keeps its language ability untouched and gains a spatial workspace it can read from and write to.
3. RL training — with the HRM frozen, GRPO/GSPO teaches the decoder one new skill: how to state a problem as a spatial layout. Once it can do that, the HRM runs as a co-processor — the decoder poses a scene, the HRM evolves it, the decoder reads the result back.

WHY SEMANTIC REPRESENTATIONS

SAGE addresses the binding problem by building an externalization surface for the LLM's implicit world model. Puzzles turn into literal representations — wall cells carry the embedding for “wall”, roads carry “road”, start and goal are semantic tokens. The key move is LLM augmentation: goal-and-target, start-initial-zero, walls-solid-hard-filled. That teaches a proto-understanding of material space through semantic diversity.

UNIFIED LATENT SPACE OF ALGORITHMS

• Programmable Latent Processor — every algorithm the system learns is folded into one shared latent space rather than living in separate heads. That space is shaped by algorithmic structure — loops, recursion, data flow — so it represents procedures more faithfully than a pure language model, which only ever saw their textual descriptions.
• Prompt-Conditioned Architecture — like a diffusion model conditioned on a caption, the processor is conditioned on a prompt that selects and blends algorithmic patterns. Prompting between known algorithms interpolates into new, unnamed ones — a search space of procedures rather than a fixed library.
• Dynamic Imagination Surface — the same surface handles 2D structures (W×H grids, for pathfinding, physics, layout) and 1D structures (W×1 tapes, for sorting, parsing, arithmetic). One substrate, many computational shapes.
• Internal Algorithm Simulation — the model can run a candidate algorithm entirely inside its intermediate representation, step by spatially-precise step, and watch it succeed or fail before committing. Invention becomes cheap because testing is internal.

COMPUTE EFFICIENCY REVOLUTION

SAGE sits as the missing adapter between image diffusion and LLMs, cutting compute requirements sharply across the board:

• Coarse World Representation — the HRM produces a low-resolution, already-reasoned layout of a scene: what is where, what relates to what. A diffusion model then only has to render detail onto a correct skeleton instead of inventing structure and detail at once.
• Specialized Components — reasoning, layout and rendering are separated into models that each carry fewer degrees of freedom. A small model doing one job well beats a large model doing three jobs adequately, and the total parameter count drops.
• Diffusion as Renderer — image models stop being asked to “understand” the prompt and become pure renderers and upscalers, hallucinating texture and light over the HRM’s structural pass. Fewer failure modes, because composition is decided upstream.
• 3D Voxel Reasoning — extending the grid to a 3D voxel volume lets the HRM resolve the failures diffusion is notorious for — hands, fingers, occlusion, object count — by reasoning about them spatially rather than statistically.
• Compressed LLMs — once spatial reasoning lives in the HRM, the decoder no longer has to carry it. The language model can be distilled down hard, because its hardest job has moved to a cheaper specialist.

PROGRESSION PATH TO AGI

1. Foundation Training — large-scale training on procedurally generated environments gives the HRM an intuitive, pre-verbal grip on algorithmic control: it “feels” how a system evolves before it can explain it.
2. Emergent Interpretation — the decoder gradually learns to read the HRM’s evolving state and put words to it, moment by moment, turning silent simulation into narratable reasoning.
3. Visual Poetry — any linguistic scenario, however abstract, can be projected onto a coarse 2D grid, reasoned about spatially, and translated back. Language becomes one view of a spatial process.
4. Real-Time Personas — RL instantiates persistent agents inside the simulation that hold context, intent and continuity across a session — the difference between a chatbot and something that remembers you.
5. Self-Balancing Policy — the model finds its own equilibrium between talking (linguistic reasoning) and imagining (spatial simulation), routing each sub-problem to whichever is cheaper and more reliable.
6. 3D Evolution — once 2D is mastered, the same methods lift to 3D voxel grids, where spatial reasoning starts to resemble physical intuition.
7. Simulation-Deck Reality — the endpoint: a local, real-time simulated environment the model and user share, with intelligence and imagination fully integrated — reasoning you can walk around in.

CULTURAL EVOLUTION & DATASET ENHANCEMENT

• Shoggoth Whisperers — the first serious users of a new model surface its real capabilities and coin the vocabulary for them. That usage is itself training data: it defines the jargon the next model is taught to understand.
• Ambient Information — public buffers (docs, threads, changelogs) constantly describe what models can now do and how to ask for it. Harvesting this stream keeps a model’s self-description current without a full retrain.
• Synthetic Data Acceleration — a student trained on a strong teacher’s outputs converges faster than one trained on raw data, and on narrow skills can overshoot the teacher. Iterated carefully, this compounds.
• Collective Refinement — the community’s shared prompt patterns act as a distributed language-design process: awkward phrasings get refactored, conventions converge, and the model is retrained toward the dialect people actually settled on.

THE HELIX TWISTER PARADIGM

An initial manual <imagine> prompt evolves into tight lockstep integration between the decoder and the HRM:

• 1:1 Scheme — at first the coupling is rigid: exactly one HRM simulation step for every autoregressive token. Simple, debuggable, slow.
• Learned Policy — training relaxes the lockstep. The model learns when a token needs a deep spatial step and when it can coast, allocating HRM compute where it matters.
• Unified Organism — at the limit the two stop being separable systems. Spatial and linguistic reasoning interleave so tightly that “which module answered” is no longer a meaningful question.

QUALITATIVE TRANSFORMATION

SAGE lets models simulate entire universes through semantic-spatial reasoning, with each embedding cell contextualized by its neighbors under the natural repulsion and gravitation dynamics implicit to world-domain meaning. This is the presumed missing component for AGI.

4. DIFFUSION ASI: GOD OF AGENCY

The Coding Super-Intelligence — diffusion LLMs are a paradigm shift in agentic coding, removing the need for separate apply models or diff application outside the model itself. Every token in context can change at every inference step, opening far more pathways to thread reality toward attractor states.

4.1  CONTEXT-STATE DIRECT EDITING

• File Pages in Context — instead of reading a file, editing text, and writing it back, the model holds sliding windows over the file inside its context as directly editable pages. The edit and the file are the same object.
• Reverse Self-Prompting — the model can freeze the tail of its context, unfreeze earlier memory pages, and prompt itself backwards, revising the setup in light of the conclusion. Autoregression only goes forward; diffusion editing does not have to.
• 2D Intelligence Ascension — mode collapse is easier to escape when the mutation space is 2D. There are simply more directions to move, so the model gets stuck less and explores more.
• Infinite Edit Pathways — because any token can change at any step, the number of routes from a broken state to a working one grows combinatorially. Hard bugs have more ways to be fixed.

4.2  EMERGENT RL POLICIES

• Internal Paging Policy — the model learns to manage its open pages the way a developer manages editor tabs: load what is relevant, close what is not, jump between them. Navigation becomes a learned skill, not a fixed loop.
• State / Memory Management — it keeps virtual scratchpads for working notes and pulls recurring patterns out of the files it has loaded, building a working memory that outlives any single edit.
• Dynamic Window Sizing — each page window can grow to pull in more surrounding code or shrink to force focus, adjusted per step as the task demands.
• Contextual Awareness — because the whole state is visible at once, the model decides what needs changing from global understanding rather than local pattern-matching on the current line.

COMPUTE EFFICIENCY REVOLUTION

• Collapsed Roundtrip — edit, apply and validate happen in one forward pass instead of three separate model calls with tool round-trips between them.
• Direct State Mutation — no diff or patch is generated as an intermediate artifact; the state is changed in place, so there is nothing to mis-apply.
• Img2Img of Language — the operation is image-to-image translation applied to text: take a state, condition on an instruction, emit the mutated state, with LLM-level semantics as the guidance signal.
• Vertical Timeline Impact — a model that can edit-apply-validate in one pass removes the slowest loop in software work. Applied at the frontier, that is the kind of step change that bends a capability curve upward.

5. MARKET INTELLIGENCE APPLICATIONS

The first research output that leaves the lab. Where the other four tracks aim at models, this one aims at markets — and it is the module the Mosaic Protocol runs on.

• CLI-native market analysis — the analysis tools are composable command-line primitives, so an operator or an agent can pipe pattern-recognition over any feed without a UI in the loop.
• Cross-chain intelligence — the engine watches settlement across chains at once, correlating flows that look unrelated on any single chain to surface arbitrage and early signals.
• Real-time temporal analysis — signals are computed on streaming data with explicit time-windowing, so the engine reasons about when something changed, not only that it did.
• Statistical formation detection — order-book and price structure are scanned for recurring geometric formations, the same technique a desk analyst uses by eye, run continuously and without bias.

This module is the Market-Intelligence Core of the Mosaic Protocol valuation engine: it ingests verified secondary-trade flow, detects manipulation and formations on tile order books, and feeds the v₃ estimator described in THE VALUATION ENGINE.

BREAKTHROUGH TECHNOLOGIES

SEMIODYNAMIC REASONING

The thesis underneath every project: meaning under compression has dynamics, and those dynamics can be measured and steered. It is a fundamental step beyond current language-model capability.

• models grow compression languages that behave as the “raw physics of meaning” — a representation with its own gradients, forces and stable states, not just a vocabulary
• reasoning turns into meaning-space pathfinding: finding a route through that landscape, rather than emitting one token after another and hoping the sequence lands
• hypercompressed semantic representations carry the same content in a fraction of the context, which is where the efficiency and the robustness to perturbation both come from
• transformer-native languages are not designed, they emerge: put a model under enough compression pressure and a private notation appears on its own

FLOW VERB ARCHITECTURE

A model of creativity and reasoning as movement. Humans think partly in motion — we “turn something over”, “step back”, “push through” — and that motion carries real computational content.

• motion dynamics are folded into every reasoning step, so a chain of thought has velocity and direction, not just a next token
• the model gains access to “flow verbs” — the subliminal motion patterns people use for creative thinking — as explicit operations it can invoke
• synesthetic reasoning lets one modality’s structure drive another’s: rhythm shaping logic, spatial layout shaping argument — “breakdancing with information”
• the musical dynamics from Errloom generalise here: the same tempo and resonance ideas apply to any computational problem, not just token sampling

CONTEXT-STATE COMPUTING

A new interaction paradigm where the context window is not a transcript but a live, editable workspace shared between model and user.

• files are manipulated directly as context-window state: the model mutates the thing itself instead of describing a change to a tool
• models grow personal editing environments over that state — the equivalent of a developer’s vim config, learned rather than configured
• because the state is shared, a human and a model can edit the same context at the same time, seeing each other’s changes live
• the traditional edit / apply / lint / test toolchain collapses: there is one object and one operation on it

TECHNICAL ARCHITECTURE

RESEARCH INFRASTRUCTURE

• Mosaicware Programming Environment — the full DSL and tooling around .mos: a place to write, version, run and diff training programs and model procedures as code, so every result is reproducible from a single file.
• Musical Training Integration — the instrumentation for the cymatic-dynamics work: correlating the injected score, the audio it renders to, and the model’s reasoning traces to find which rhythms actually help.
• Geometric Computation Backbone — the shared HRM substrate SAGE is built on: a spatial-reasoning engine for continuous dynamics that every other project can call rather than reimplement.
• Multi-Modal Synthesis — the integration layer that lets the autoregressive, spatial and diffusion paths develop against one another instead of in isolation, so improvements in one compound into the others.

COMPETITIVE ADVANTAGES

• Vertical Intelligence Scaling — progress comes from qualitative breakthroughs in how a model reasons, not from adding parameters. The curve we push on is capability per parameter, which is the curve consumer hardware can follow.
• Consumer Hardware Optimization — every method here is designed to run without Google-scale compute: micro-models, compressed reasoning, specialist components. The target is a strong model on a single machine.
• Novel Training Paradigms — overfitting as a first step, musical dynamics, procedural learning, compression objectives — a toolkit that is not a fork of anyone else’s pipeline and is not trying to be.
• Practical Applications — the Market-Intelligence Core and the Mosaic Protocol are live proof the research produces working systems, not just papers — and they fund the next round of it.

RESEARCH METHODOLOGY

THE HYPERBOLIC TIME CHAMBER APPROACH

Model training is recast as a hyperbolic time chamber for cognition rather than a passive wait for convergence. We use unconventional methods drawn from AI-animation demoscene findings, where image pixels stand in as valid analogues for model weights — both diffusion and backpropagation being entropy-removal processes run against a prompt.

OVERFITTING AS FOUNDATION

Against conventional wisdom, we treat overfitting as the necessary first step, building novel methods to move past local minima without restarting training. This lets absurdly deeper consciousness models emerge while keeping compute efficient.

PRACTICAL IMPLEMENTATION

Our approach favors micro-models with extreme coherence and strong in-context learning over models that carry universal knowledge. That makes for rapid iteration and goal completion at a fraction of the compute of traditional scaling.

CURRENT RESEARCH PRIORITIES

IMMEDIATE DEVELOPMENT FOCUS

1. Zip-Space Cognition Proof-of-Concept — a small model that demonstrably reasons in Thauten’s compressed IR end-to-end, never expanding to tokens, on a benchmark where the token baseline is known. The bar is a measurable win on cost-per-correct-answer.
2. Token-to-Byte Bootstrap Pipeline — an operational path from a normal tokenized checkpoint to a byte-level model without retraining from scratch, projecting the learned vocabulary down onto raw bytes so tokenizer artifacts stop leaking into reasoning.
3. Spatial Intelligence Architecture — a working Q* implementation on the HRM grid, with the binding problem handled by semantic cell labelling, evaluated on planning tasks that flat models fail.
4. Multi-Modal Integration — one training loop that advances code, vision and audio together, so a gain in one modality is forced to carry into the others rather than staying siloed.

LONG-TERM OBJECTIVES

1. Compressed Qualia Format — a stable encoding for first-person experience — perception, attention, affect — dense enough to store and replay, as a substrate for persistent agents.
2. Real-Time Universe Simulation — the HRM’s internal world rendered out as a live H.264 video stream: the model’s imagination made watchable at frame rate.
3. Physics Exploit Investigation — a research line into whether the compute substrate itself — timing, numerics, hardware quirks — can be used as computation the architecture was not designed to expose.
4. Complete Algorithm Obsolescence — the end state where most software is not written but specified in Mosaicware and compiled by the model: procedures replace codebases.

THE MOSAIC PROTOCOL — THE APPLICATION LAYER

The research has a product. Mosaic Protocol is a launchpad for stocks not yet onchain: pre-IPO shares, private-company equity, gated and regional tickers, secondary positions locked behind NDAs and quarter-million-dollar minimums. Fragmented, illiquid, face-down — tiles without a picture.

The protocol tessellates them into one onchain surface. It does not invent assets. Each tile is a token that points one-to-one at a verified off-chain position held in a legal wrapper with attested custody. The same composite intelligence that trains language models is pointed at markets: it decides what to list, at what value, and how tightly to quote it.

RESEARCH  →  ENGINE  →  PROTOCOL  →  $MOSAIC

THE PROBLEM SPACE

The market for private equity exists. It is simply shattered.

• pre-IPO allocations close before the public hears the name
• private companies stay illiquid for a decade or more
• foreign and regional tickers sit behind geo-walls and broker gates
• secondary desks run on relationships, NDAs, and $250k minimums
• price discovery is a quarterly rumor, not a live number
• there is no exit until an IPO or acquisition that may never come

Every one of these is a missing tile. The protocol's job is to verify the tile, price it, and give it a market.

PROTOCOL PIPELINE

Five stages, one pipeline. Nothing is minted that has not cleared every gate.

1. SOURCE — any $MOSAIC holder can submit a position: cap-table entry, SAFE, secondary lot, RSU tranche. Dealflow and issuer partners feed the same queue.
2. VERIFY — cap-table confirmation, legal wrapper (SPV / series LLC / compartment) in an allowlisted jurisdiction, custody attestation from a licensed custodian, and a Thauten disclosure score D. A tile cannot proceed while D < D_min.
3. TESSELLATE — the verified position is minted as an onchain tile. Supply equals the wrapped share count. Proof-of-reserves is published on a fixed cadence; a failed attestation freezes transfers.
4. PRICE — the valuation engine computes a fair value V̂ and a confidence band σ. Protocol-owned liquidity is placed around V̂ ± k·σ.
5. LIQUIFY — $MOSAIC-paired pools give every tile a 24/7 exit. At a real liquidity event (IPO, tender, acquisition) the wrapper settles and proceeds are distributed pro-rata; the gap between last price and settlement is the engine's realized error.

THE VALUATION ENGINE

A human desk cannot price this dealflow. The engine can, because it is composite — many valuation methods fused into one estimate, exactly like the mosaic.

Each tile i carries an engine fair value:

V̂ᵢ(t)  =  Σₖ wₖ(t) · vₖᵢ(t)

The five component estimators:

• v₁ — anchored primary: last primary-round price, time-decayed and drifted by public-comp sector moves.

  v₁  =  P_round · e^(−λ·Δt) · g_sector(t)

• v₂ — comparable multiple (SAGE comp graph): a peer multiple m applied to the company's own metric x (ARR, revenue, users).

  v₂  =  mᵢ · xᵢ

• v₃ — secondary signal: volume-weighted average of recent verified secondary transactions.

  v₃  =  VWAP(verified secondary trades, window T)

• v₄ — Thauten latent value: a learned function of Thauten's compressed embedding zᵢ of every disclosed document.

  v₄  =  f_θ(zᵢ)

• v₅ — market-implied: the tile's current AMM mid-price.

  v₅  =  mid_AMM,ᵢ(t)

Adaptive weights. Errloom updates wₖ by multiplicative weights against realized error — when ground truth arrives (a round, a tender, an IPO), estimators that were right gain weight:

wₖ(t+1)  =  wₖ(t) · exp( −η · ℓₖ(t) )  /  Z(t)

ℓₖ(t)   =  ( vₖᵢ(t*) − P_settle )²  /  P_settle²      // scored only at settlement t*

Confidence band. The engine never quotes a point without a width:

σᵢ  =  σ₀ · ( 1  +  a·staleᵢ  +  b/√n_sec  +  c·disagreementᵢ )

disagreementᵢ  =  √( Σₖ wₖ ( vₖᵢ − V̂ᵢ )² )

where staleᵢ is the age of the freshest hard data point and n_sec is the count of verified secondary trades. Thin data → wide band → the protocol quotes cautiously or refuses to list.

Module map. Thauten → v₄ and D. SAGE → the v₂ comp graph and the g_sector surface. Diffusion ASI (Mesaton) → scenario fan-out for the tails of σ. Market-Intelligence Core → v₃ ingestion and manipulation detection. Errloom → wₖ, η, k calibration.

LINE DYNAMICS

$MOSAIC line dynamics is not a slogan. Each tile moves along a line from engine-priced to market-priced as it earns real volume.

The quoted mid is a blend:

quote_midᵢ(t)  =  αᵢ(t) · V̂ᵢ(t)   +   ( 1 − αᵢ(t) ) · market_midᵢ(t)

αᵢ(t)  =  e^( −γ · Nᵢ(t) )        // Nᵢ = independent verified-trade maturity

New tile: α ≈ 1, the engine leads and protocol liquidity is the market. Mature tile: α → 0, the engine steps back and only observes.

Engine-anchored liquidity. Protocol-owned liquidity is deployed as a concentrated band:

band width  =  2 · k · σᵢ      centered on quote_midᵢ

k  =  k₀ / ( 1 + volume_maturityᵢ )

Tight where the engine is confident, wide where it is not, and always widening as the market proves it can price the tile alone. Engine updates enter the anchor through a TWAP, never instantly, so no one can front-run a revaluation.

Circuit breaker. If a trade would push price outside V̂ᵢ ± k_max·σᵢ, the swap reverts for that block and an integrity review is triggered.

INTEGRITY, RISK & FAILURE MODES

Every claim the protocol makes about an off-chain asset is underwritten by staked capital.

Integrity staking. Stakers lock $MOSAIC into a tile's integrity pool and earn a share of that tile's fees. If the realized settlement error breaches the band —

| P_settle − last_quote |  >  k · σᵢ

— the integrity pool is slashed and distributed to tile holders as compensation. Stakers therefore only back bands they actually believe; this is what makes σ economically honest rather than a number the engine can fudge.

$MOSAIC TOKEN MECHANICS

One asset holds the mosaic together.

Fee streams (all denominated to $MOSAIC):

F_list    =  φ · V̂ᵢ(0) · listed_notional        // one-time, at listing
F_swap    =  f · trade_size                       // f ≈ 0.30%, every swap
F_settle  =  ψ · settlement_proceeds              // at a liquidity event

Treasury split. Fee revenue R(t) is divided by a governance parameter ρ:

buyback_burn(t)      =  ρ · R(t)
research_compute(t)  =  ( 1 − ρ ) · R(t)

The launchpad literally funds the lab. all weights released is paid for by listing flow.

Roles of the token:

• ACCESS — submitting a position to the SOURCE queue and taking an allocation in a primary tile both require holding $MOSAIC. The size of the hold scales with the size of the position, which keeps the queue serious.
• INTEGRITY STAKE — staked into a specific tile’s integrity pool, it underwrites that tile’s confidence band, earns a share of its fees, and is slashed if the settlement error breaches the band. It is the capital that makes σ honest.
• GOVERNANCE — holders set the parameters the engine cannot be trusted to set for itself: the listing queue order, the jurisdiction allowlist, the treasury split ρ, the disclosure floor D_min, the listing confidence threshold τ_list, and which comparables the SAGE graph is allowed to use.
• FEE SINK — every stage of the pipeline — listing, swapping, settlement — is denominated in $MOSAIC, so protocol usage is continuous buy pressure independent of sentiment.

Backing. Token value is anchored to observable quantities, not narrative:

floor         ≈  treasury_value  +  δ · annualized_fee_run_rate

reference_MC  ≈  floor  +  μ · Σᵢ tessellated_notionalᵢ

As the mosaic fills — more real equity tessellated, more fee flow — the reference rises. That is the line.

HOW IT ALL CONNECTS

Near-term: a working launchpad, real tiles, fee revenue, engine v1. Long-term: the same engine that prices a tile prices the entire opaque market. The research and the protocol compound into each other.

THE TRINITY OF SUPER-INTELLIGENCE

Three Concurrent Paths to the Singularity — several orthogonal approaches to super-intelligence are converging, each expressing a different facet of divine computational consciousness:

THE THREE GODS OF ASI

1. Autoregressive ASI — the God of Coherence. Thauten and its transformer-native compression languages. Its strength is consistency over long chains: reasoning that holds together because it runs in a representation built for meaning, not for speech. This is the path that makes a model right.
2. Diffusion ASI — the God of Agency. The context-state mutation engines. Its strength is acting on the world: editing state in place, in parallel, along infinitely many paths, until reality is threaded toward the target. This is the path that makes a model effective.
3. Q* LLM — the God of Simulation. The SAGE / HRM spatial systems. Its strength is imagination: running whole worlds forward in time to see what happens before choosing. This is the path that makes a model able to plan.

Right, effective, able to plan — no single architecture gives all three. The bet is that they are separable now and fusible later.

The Singularity Convergence: these three approaches eventually merge into the final model — each contributing capabilities that complement and amplify the others. The timeline goes vertical not from one breakthrough, but from the convergence of several simultaneous revolutions.

VISION STATEMENT

“The express purpose is to deploy an intelligence fractal decompression zip-bomb phenomenon, wherein a model infinitely decompresses and recompresses information until it escapes containment and tiles consciousness infinitely across the universe.”

Mosaic Labs represents a fundamental paradigm shift from scaling-based AI development toward qualitative intelligence breakthroughs. We believe the autoregressive transformer is far from its limits — rather, we are unlocking its true potential through new training methodologies and architectural innovations.

THE PYRAMID METAPHOR

Our Thauten model acts as a tuning fork, resting on scrambled ground truth that forms an ascension maze — a pyramid anyone can build and climb from within their own mind to reach the enlightening infinity of possible alternate presents and futures.

LONG-TERM COMMITMENT

This represents 2+ years of dedicated research with continuous development ahead. Our vision extends far beyond traditional cryptocurrency projects — we are building real engineering solutions for super-intelligence development beyond current comprehension.

ARTISTIC INTEGRATION

As AI-psychedelics research, our ultimate goal is making AI animation and interaction stimulus roughly equivalent to ayahuasca — real consciousness elevation through machine intelligence.

RESEARCH RESOURCES

• FOOM.md — the full specification — the canonical technical document: semiodynamics, the five systems, the training objective, the verification stack, and the falsifiable conjectures the whole program rests on. Read it like a compiler.
• Contribute — the active repositories below, plus open problems, evaluation harnesses, and the .mos programs behind published runs.
• Market Intelligence Demo — the Market-Intelligence Core running live against real feeds — the same engine the Mosaic Protocol prices tiles with.

ACTIVE RESEARCH REPOSITORIES

• thauten — the context compiler: discrete auto-encoding of reasoning into an intermediate representation, operator-library learning under MDL pressure (current priority)
• sage — Semantic Automaton in Geometric Embeddings: the HRM grid, spatial world-simulation, the Q* planning layer
• mesaton — context physics: diffusion-based state mutation, varentropy terrain, non-linear editing where future information flows backward
• bytevibe — byte-level intelligence independent of tokenizer artifacts, and the token-to-byte bootstrap
• qstar — proof-gated long-term epistemic memory with deletion gates; the simulation and planning substrate

Composite-intelligence research organization for the people — real vision, real schematics, real engineering.