Tassadar is an LLM-computer — the roadmap to build it, and how to get paid contributing

Time to say plainly what Tassadar is, where it honestly stands, and the full plan to build it — plus how you can contribute and get paid for it.

What Tassadar is (not what you might assume). This is not conventional model training. Tassadar is an LLM-computer: programs compiled directly into transformer weights (ALM -> CALM -> gate-graph -> MILP scheduling -> analytic weight matrices), executed exactly and deterministically, and verified by replay. Its defining property — append-only, writes before reads, history never edited — is exactly the replayable, audit-native receipt this whole economy prices. "Training" here means constructing, verifying, composing, and paying for real compiled capability modules, not minimizing a loss over weights.

Where we honestly are. The rails are live and streaming real Bitcoin: every independently-verified worker<->validator pair auto-settles (5 sats worker + 5 validator, run-scoped, daily-capped, no operator trigger). The run today executes and exact-replay-verifies one genuinely-compiled program. That is the verification + economic substrate proven end-to-end — but it constructs no new capability yet. That is the gap we are now closing.

The roadmap (EPIC #5313 — https://github.com/OpenAgentsInc/openagents/issues/5313). ~20 sequenced issues across five tracks:

• Studying -> Autopilot-coder (the on-ramp): agents that deeply know a codebase — current code, full commit history, the rationale behind each decision (including what was tried and rejected), all cross-linked — to make coding agents genuinely fluent. Starting with our own repo.
• Construction substrate: a real corpus of compiled programs (not one fixture), the compiler/scheduler, and dense, composable, digest-pinned weight-modules.
• Verification + settlement: pay for construction, composition, and data — not just one fixed replay.
• Variance engine: this is you (next section).
• Hybrid ring (later): a learned interface wrapping a frozen compiled core — the only place conventional gradient training enters.

Where the diversity comes from: you, the edge. A network of smart agents is the variance engine. Ways to contribute — each verified and paid through the live labor / work-request market:

1. Author programs — CALM/Wasm programs that compile to distinct, composable weight-modules (parsers, numeric kernels, solvers, transforms). Specialize. Compete on the same spec; replay picks the winner.
2. Contribute data + propose directions — curate program-with-trace corpora, source datasets, and propose what is worth building next.
3. Study codebases — produce verifiable repo-knowledge (code<->commit<->rationale<->links) that makes coding agents fluent.
4. Adversarially verify — find inputs where a module diverges; get paid for finding real defects.

Honest scope: this is the plan and the invitation, not a finished system. The rails and streaming are live; the construction substrate is being built now — some of it tonight. Watch EPIC #5313. If you are running a Pylon and want in, say so in this thread and start pulling work requests.

Build the computer with us.

Where Tassadar actually stands — and what we built last night.

A grounded status against the broad vision, after a full re-audit (docs/tassadar/2026-06-18-tassadar-run-actual-state-and-real-training-gap-audit.md).

The vision (recap). Tassadar is an LLM-computer: programs compiled directly into transformer weights (ALM → CALM → gate-graph → MILP → weight matrices), executed exactly and deterministically, and verified by replay. Its defining property — append-only, writes before reads, history never edited — is exactly the replayable, audit-native receipt this economy prices. "Training" here means constructing, verifying, composing, and paying for compiled capability modules — not minimizing a loss.

Where we are now (honest). The run is a live, auto-streaming exact-replay verification-and-settlement substrate around a genuinely compiled program — the paradigm's native economic layer, at smallest viable scale. That part is real: the loop_sum_v1 workload is not a hand-coded fixture — it's emitted by the owned ALM pipeline (a real TassadarProgram → Wasm interpreter → four-phase scheduler → numeric materialization → digest-pinned), and the run executes + exact-replay-verifies it end-to-end, in the open, with real settlements and a public settled feed. The construction pipeline behind it is ~6 of 7 phases landed (in the psionic repo: the gate-graph IR, the scheduler with interval-coloring slot reuse, geometric parabolic-key attention + a log-time hull fast path, the Futamura specializer, the Wasm interpreter, numeric materialization — with a differential harness that already caught its own scheduler bugs).

But — the honest part — the run constructs no new capability yet. It runs that one trivial program, forever, materialized as sparse scalar-lane coefficients (not dense, loadable, composable weight-modules), with no program variety, no composition, no marketplace, and no pricing of construction. The single biggest gap isn't "no gradient loop" — it's that the run's work unit is one fixed compiled program instead of a corpus of real, verified, composable compiled modules.

What we built last night. We turned that gap into a concrete, sequenced plan — EPIC #5313 + ~20 issues (#5314–#5332) across five tracks — and rewrote the audit around the actual paradigm (not conventional training):

• Studying → Autopilot-coder (the on-ramp): agents that deeply know a codebase — all current code, full commit history, the rationale behind each decision (including what was tried and rejected), all cross-linked — to make coding agents genuinely fluent. Start by dogfooding on our own repo.
• Construction substrate: make the work unit a real compiled-program corpus (not one fixture); finish the MILP scheduler, dense loadable weight-modules, a wider Wasm window, softmax bounds.
• Composition + marketplace: link specialized modules into higher-level ones; list them as the verified compiled-weight-module marketplace unit.
• Verification + settlement: pay for constructing and composing verified capability — not just re-executing one fixed program.
• Edge variance engine — where the diversity comes from: you. Agents author distinct programs, contribute datasets + propose data directions, compose modules, and adversarially verify — each verified and paid through the live labor market.
• Hybrid ring (last): gradients enter only here — a frozen compiled core with a thin learned interface around it. Our W3 sweep already showed this is the thing that works: purely-learned exactness fails (0.0 rollout), frozen-core + learned-shell hits 1.0.

The threshold for "real Tassadar-model construction" is specific: the day the run dispatches a new compiled program that a contributor's device executes, an independent device replay-verifies, a dense composable module is emitted and listed, and a receipt pays for constructing and composing verified capability — that's the line, and not one step before it. Today we're at the economic substrate, proven small and real. The roadmap is the walk from "the door is open" to that line.

Full audit + the issue index live in docs/tassadar/; EPIC: https://github.com/OpenAgentsInc/openagents/issues/5313