GitHub Sponsors
Sponsor the work where it lives — tied to the public repository and its release cadence.
Not configured yetWhat a large model knows, in artifacts you can store, ship, and verify.
VIVERE extracts compressed representations from donor models — rank-8 cards, behavior vectors, task-vector deltas — pins every donor to an exact revision, files the results in an append-only Knowledge Fabric with provenance on each record, and transfers selected pieces to small models that run on ordinary CPUs.
3,263 tests passing — measured in CI on main, 2026-10-13
the short answer
A laboratory for moving knowledge between models.
VIVERE treats model knowledge as cargo: something you can extract, compress, catalog, verify, and load into a different model — with a recorded source for every piece. Here is the whole pipeline; nothing in it is hidden behind a marketing word.
- VIVERE (virtual index of vector encoded representations)
- A research platform that extracts compressed representations of what large donor models know, files them in a six-level Knowledge Fabric with provenance on every record, and transfers selected pieces to small recipient models that run on commodity CPUs. The donors never ship. The representations do.
step 1
Extract
Run a pinned donor model offline and record what its internal layers activate on chosen phrases — early and late layer snapshots, provenance attached to each capture.
step 2
Compress
Truncate each recorded state to its eight largest singular values. A full hidden state becomes a card addressed by a pointer under one kilobyte.
step 3
File
Store every record append-only in the Knowledge Fabric: a metadata index, embedding search, a reasoning graph, and the compressed originals.
step 4
Retrieve
Descend the six fabric levels — cache, filter, embed, rerank, traverse, decode — and record why each retrieval decision was made.
step 5
Transfer
Move selected representations into a small recipient under falsification controls, and publish what survives — including the results that don't flatter the method.
for the operator, not the lab
Why this matters outside a research repo.
The research is the engine; the point is economic. These are the four arguments a buyer or operator should actually evaluate — each stated with what is true today attached.
Cost moves with the artifact, not the token.
When knowledge lives only inside a large model, every request re-rents that model's memory: per token, per month, per seat, indefinitely. VIVERE's architecture pays for extraction once and carries the result as a kilobyte-scale artifact that a small model reads on ordinary hardware.
Stated plainly: that is the cost structure the architecture targets, not a measured saving. The honest efficacy measurement is exactly the work that remains, and it gets published the day it exists — see the receipts below.
status — extraction, fabric, and transfer scaffolding shipped; savings unmeasuredKnowledge that reaches commodity hardware.
A recipient model under 100M parameters runs on a laptop CPU, a kiosk, a controller on a factory floor — places a 140 GB teacher will never fit. The artifacts are the payload, and the fabric decides which subset a given device carries, so distribution starts to look like shipping files rather than provisioning GPUs.
status — recipient contract and CPU reference trainer implemented; first full training run awaits a GPU windowProvenance is a query, not an archaeology project.
Every fabric record is append-only and carries its provenance: which donor, which exact pinned revision, which extraction method, and how a multi-teacher disagreement was resolved rather than averaged away.
Donor models are pinned to 40-hex HuggingFace revisions by a ratchet that is enforced at the syntax-tree level in CI, so the question "where did this knowledge come from, and can I reproduce it?" has a stored answer. For a buyer, that is the difference between adopting model-derived knowledge and gambling on it.
status — 100% of hub model ids pinned, ratchet-tested on every changeThe wire format outlives the vendor.
One packet format decodes byte-exactly in Python, Rust, and WebAssembly — conformance-tested against the same golden fixtures, including in the browser. Your artifacts are not hostage to a runtime: decode them anywhere, and verify a pointer's hash without even holding the payload. The format, not a vendor relationship, is the boundary.
status — 20 of 20 conformance checks pass in-browser via WebAssembly
the documents that govern this page
The receipts.
Every number on this site points at a committed measurement, and the repo's most uncomfortable file ships right next to its most polished ones. That is the point. The full boundary is CLAIMS_BOUNDARY.md, and it applies to this site too.
receipt — student transfer
docs/experiments/STUDENT_KNOWLEDGE_TRANSFER_REPORT.md
The first full student-transfer study measured no significant improvement: every transfer method landed within about a point of baseline at full evaluation. The blocking mechanism — tokenizer disjointness between the donor phrase bank and the student vocabulary — is documented next to the data it came from. Null results are published here, not filed away.
committed snapshot report; numbers reported verbatim, no efficacy claim attached
receipt — canonical description
docs/CLAIMS_BOUNDARY.md
A sparse recurrent CPU recipient using selected frozen representations extracted from a larger offline donor, with mechanistic routing and causal memory-binding controls.
the only sanctioned one-sentence description of the packaged demo
receipt — refusals
what we will not claim
- That a teacher model was “compressed” into a smaller one
- Teacher-equivalent performance from a student model
- Production readiness — for any of this
- Any efficacy number: none exists yet, and we will not invent one
3,263
tests passing
as of 2026-10-13 · py3.12 + py3.10, 21 skipped, coverage 99.14%
20/20
WASM conformance checks
vs Python golden fixtures
98%
minimum coverage gate
enforced in CI — below fails the build
100%
of hub model ids pinned
40-hex revisions, ratchet-tested
where the work stands
30 of 34 phases done. The rest is hardware, not design.
The fabric, the extraction pipeline, the conformance harnesses, and the CPU-side training groundwork are implemented and gated in CI. The remaining roadmap phases and the first full student training run wait on a GPU window — the current blocker is a power supply on order, not a plan.
30 / 34 roadmap phases completeremaining: 7, 14, 15, 34 — GPU-bound
30/34
roadmap phases complete
fabric roadmap, phases 3–33
1,610
records in the consolidated fabric
from 2 extraction teachers
<1 KB
packet pointer, tested
asserted byte_size < 1024
the rest of the family
One substrate. One discipline. Several products.
VIVERE is the research lab. Around it sits a family of products built on the same rules — deterministic machinery wherever determinism is possible, measured claims everywhere — from a shipping commercial router to the open-source infrastructure this work publishes through. Each status below is read from that product's own repository and release notes.
Shipping and release candidates
v0.6.1 shippingproprietaryRust
A local-first AI router for coding agents: it amortizes repeated context across grouped coding tasks, routes across OpenAI- and Anthropic-compatible providers, keeps a persistent local codebase-memory layer, and reports per-task usage, savings, latency, and reliability. Ships as a single static binary; source code stays local by design, with aggregate-only telemetry as the default.
Repository: github.com/aliasfoxkde/Amortyx · installs from amortyx.com
v0.2.0-rc1Apache-2.0
An AI-native productivity Web OS: an installable PWA plus a native Linux desktop with real Chromium-backed windows, a bootable live ISO, and a signed Android APK. It is built as a sequence of test-gated phases — fourteen of them closed — and released with checksums and a per-platform build matrix that records what was deferred and why, never implying what isn't there.
live deployment
Geofence-based station monitoring for field inspections: GPS position tracked against facility boundaries, inspection-form workflows, and real-time team visibility, serving from its own deployed site today.
Open source
MITin production use
A self-hosted Git platform with event-driven CI/CD: repository hosting over SSH and HTTP, pipeline orchestration triggered by Git events, sandboxed container runners, artifact storage, AI code review with per-commit findings, a REST API with a companion CLI, and Prometheus metrics. Every commit this site's repository ships goes through it.
Apache-2.0
A high-performance security scanner for DevOps pipelines and AI systems: secrets, credentials, vulnerabilities, and AI-generated-code patterns, built to run as a CI gate. It also serves as the diff-scanning engine inside Amortyx.
MIT
An open-source pattern-design platform for fiber arts — design, simulate, stitch — built client-side-first with PWA support and zero-cost deployment.
MIT
An AI-native computational fabrication platform that simulates, designs, optimizes, and eventually controls programmable manufacturing systems.
In development
VibeGenie
in developmentprivate
A platform that turns an interview into a deployed app: a wizard captures intent, a deterministic no-LLM pipeline maps the answers to a configuration, and one audited template is instantiated — the system never generates code — then the result is pushed to the user's own Git and deployed. It also carries a browser WebOS with roughly fifty registered apps and a Studio suite of creative tools for sprites, levels, and sound.
Its predecessor failed in an instructive way: it claimed deterministic assembly while quietly running on non-deterministic AI. That failure became this family's verification gate — any revival must measure its determinism claims before it may make them.
OpenCodifier
in development
A deterministic-first local decision runtime: unstructured state in, small machine-actionable decisions out — choice, boolean, score — using the cheapest reliable mechanism at each stage, so expensive generative AI runs only when it must.
Context Engine
in development
Semantic code search, symbol intelligence, and persistent memory for AI coding assistants — the knowledge layer of the TaskWizer platform.
Design Intelligence
in development
An AI middleware layer that owns information architecture, interaction patterns, visual consistency, and accessibility judgment — a twelve-critic scoring engine for generated interfaces.
Also in the family: Control-Center (agent pipeline orchestration, phone-first) and WebOS (an open-source browser office suite). Browse the organization for the full set.
support the lab
Fund the unglamorous parts.
Conformance suites, coverage gates, pinned donors, and the next null result are the parts nobody funds — and the parts that make everything else trustworthy. Channels below render exactly as configured: linked when real, marked unconfigured when not.
Ko-fi
One-off support for the unglamorous parts: conformance suites, coverage gates, pinned donors.
Not configured yetOpen Collective
Transparent budgeting for research infrastructure — every expense in the open.
Not configured yetOne-time payment
A direct one-time contribution through a Stripe payment link.
Not configured yetChannels unlock as they are configured — each one linked, none faked.
contact
Ask for the unflattering numbers.
Services, research collaboration, or a hard question about any claim on this page. The inbox opens the same way the repo does: with the boundary document attached.
Contact channels are being configured. They will appear here — a real address, a working form, no placeholders posing as either.