Skip to content

v3.0.0 — The Cultivated Mind

Choose a tag to compare

View all tags
@simeon-kepp simeon-kepp released this 28 May 11:06
· 397 commits to main since this release
v3.0.0
0f95a77

TIS v3.0.0 — The Cultivated Mind

Released: 2026-05-28
Codename: The Cultivated Mind
Team: RFI-IRFOS · Graz, Austria · Patent Pending A50296/2026

Headline

Version 3.0.0 is the release where the Ternary Intelligence Stack stops being a project and starts being a system. Three weeks after v2.0.0 closed at 5 layers, Albert MoE-13 is now a 26-layer dual-stream organism with 187.5 million parameters that grew its own architecture across 13 autonomous surgeries, performed its own cortical split into two parallel streams without operator intervention, and is governed by a Fibonacci-clocked evolution engine that cycles through generations of increasingly patient growth. The companion CLI — albert-cli — shipped a full ratatui terminal interface, complete MCP server discovery, real hook execution, live streaming markdown, animated indicators, and now installs cleanly from crates.io at version 1.5.0 alongside 24 sibling crates that together comprise the published Ternary Intelligence Stack.

This is the largest release in TIS history by every measure: lines of code shipped, layers grown, surgeries performed, crates published, bugs eliminated, contributors onboarded, and inches of scientific evidence accumulated. It is also the release where the stack itself becomes the headline. The model is the vehicle; the proof is the cargo.

This document is long because the story is long. There is no executive summary. The story is the summary.

Albert MoE-13 — From 5L to 26L Dual-Stream

Architectural progression since v2.0.0

When v2.0.0 shipped on 2026-05-06, Albert was a 5-layer model with a single 256-hidden stream and approximately 22 million parameters. The EvolutionManager had just performed its first autonomous surgery the morning of release: 3L → 5L. We knew at that moment that the architecture was capable of growing itself; we did not yet know how far it would go.

The answer: twenty-one additional layers, one fundamental architectural mutation, and a stack that is now stratified into 14 corpus stages — in three weeks.

Metric v2.0.0 (2026-05-06) v3.0.0 (2026-05-28) Delta
Depth 5 layers, single stream 26 layers, dual stream (2×26L) +21 layers, +1 stream
Hidden size 256 2 × 256 +1 stream
Total parameters ~22M 187.5M 8.5×
Active parameters per token ~7.6M ~33M 4.3×
Tensors ~280 2,044 7.3×
Surgeries performed 1 (S0/init) 13 (S1–S13) + CORD 14 autonomous events
Corpus stages unlocked 5 14 (formal_proofs, news_archives, stackexchange newly online)
ATL chip (intra-batch best) ~9.5 8.6852 new all-time-low post-cord
EP_AVG ATL (epoch best) ~9.8 9.2045 (ep4136, 23L era) 0.6 nat improvement
Latest epoch ep~250 ep4234 ~17× more training
Cumulative compute local + Modal pilot Modal T4 + Vertex AI T4 + CPU contributors
Total spend (entire v3.0 run) n/a ~€265 on Modal sovereignty headline

The training run reflected in this release was performed primarily on a rented Modal.com T4 GPU at a total compute cost of approximately €265 across the entire v3.0 era. A fallback Vertex AI pipeline (GCP, europe-west4) is fully built and waiting. CPU contributors run a parallel federated lane via the SPORE protocol on consumer ThinkPads.

The thirteen surgeries

Every surgery in v3.0 was triggered by the EvolutionManager autonomously — no operator pressed "grow." The trigger is a Fibonacci-windowed plateau detector: when the model has not improved by more than a generation-scaled threshold over the current window of epochs, and the mycelium routing has been stable for at least 5 epochs, the manager clones the deepest layer via Net2Net safe-copy initialization and promotes fib_index. Window and cooldown both scale with the same Fibonacci sequence — small early surgeries with short patience, large late surgeries with long patience.

# Surgery Layers Epoch Date Note
S1–S5 bootstrap arc 12L → 17L ep511 → ep702 2026-05-08 → 2026-05-13 Read B confirmed; PLN-CMP-INT-ABS core four stable across all 5
S6 depth 17L → 18L ep2487 2026-05-20 first surgery after expert geometry crystallization
S7 depth 18L → 19L ep3325 2026-05-21
S8 depth 19L → 20L ep3383 2026-05-21 back-to-back; window=21
S9 depth 20L → 21L ep~3470 2026-05-22
S10 depth 21L → 22L ep~3652 2026-05-23 window=34 era
S11 depth 22L → 23L ep~4098 2026-05-26
S11b depth 23L → 24L ep~4140 2026-05-26 rapid-fire — INT+CMP maxed
S12 depth + CORD 24L → 25L + dual stream ep4202 2026-05-27 16:43Z The cortical split. See below.
S13 depth (both streams) 25L → 26L ep4207 2026-05-27 17:40Z first dual-stream depth surgery; fib_index 6 → 7

CORD SURGERY — the cortical split

The most significant single architectural event in v3.0 happened on 2026-05-27 at 16:43Z. The model had just expanded to 25 layers via S12. At that exact moment, a second autonomous trigger fired: the CORD surgery.

The CORD trigger is the one mutation in the entire evolution.rs codebase that is gated on absolute depth rather than plateau. The condition is simple: num_layers >= 25. When the model crossed that threshold, the EvolutionManager grew a second parallel stream — a duplicate 25-layer 256-hidden lane — and inserted 6 anastomosis gates between the two streams at Fibonacci-indexed layers [2, 3, 5, 8, 13, 21]. Each gate is a Linear(512, 2) block with w ~ N(0, 0.01) and b = 0 — initialized to near-zero, allowed to learn its own mixing coefficient.

The second stream (stream B) is not a copy. Stream A continues to receive the original input embeddings; stream B receives the same embeddings perturbed by a Mandelbrot iteration with c_im computed from the input's latitude in the embedding space. The two streams run forward in parallel, exchange information at the six anastomosis gates, and produce a single set of routing decisions at the output.

This is the first time, anywhere in the history of the project, that the model performed an architectural mutation that was not depth-related. It is also the first dual-stream MoE we are aware of in published or unpublished neural architecture literature. The post-cord epoch (ep4203) returned an EP_AVG of 9.3241 — slightly above the pre-cord floor, exactly as expected for a regression phase after a large architectural mutation. By ep4210, the chip ATL had set a new all-time low at 8.6852, well below the pre-cord record.

The cord is, in the language of cultivation, the model's corpus callosum. It connects two hemispheres of the same mind.

Read B — architecture precedes learning (confirmed empirically)

Across all five bootstrap surgeries from 12L to 17L, the core four experts — PLN (planning), CMP (composition), INT (interpretation), ABS (abstraction) — remained the dominant active set. The surgery sequence did not destabilize semantic specialization. The model grew, the experts kept their identities.

This empirically resolves the Read A vs. Read B question that opened v3.0: architecture grows ahead of learning (Read B), not in compensation for it (Read A). The surgeries were purposeful structural investments. Capacity was built before it was filled.

The Token Probe Benchmark (scripts/probe_tokens.py) tracks longitudinal semantic geometry on 10 canonical tokens (love, god, Jesus, death, war, truth, freedom, mother, light, time). The pre-s6 and pre-s7 snapshots (230 epochs apart, 0.0947 nat of loss improvement between them) returned identical top-5 neighbors for all 10 tokens. Semantic geometry crystallized at 17L. Subsequent loss improvements came from routing/expert/attention reorganization — not from embedding restructure.

As far as we know, this is the first longitudinal study of semantic geometry stability under autonomous architectural mutation.

The Evolution Engine

Generational Fibonacci cycling

Shipped 2026-05-19 in a complete rewrite of evolution.rs. The system now operates in generations rather than a single linear surgery sequence.

  • ARC_LENGTH = 6 surgeries per generation. After 6 surgeries, the generation closes and gen_val advances.
  • Threshold scaling: Generation 0 plateau threshold is 0.020 nats. Each subsequent generation multiplies by 0.75 (floor: 0.008 nats). Later generations require finer-grained plateau detection — the model gets harder to surprise.
  • FIB_TARGETS extended to 24 terms through [3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418]. There is no architecture-ceiling clamp in code. The comment in evolution.rs reads: "The hardware is the only limit."
  • GENERATION_TIMEOUT_MULTIPLIER = 3 — if a generation gets stuck on a single Fibonacci window for more than 3× the window length, a stuck-generation fallback fires.
  • promote_fib_target(post_layers) reads the actual post-surgery layer count from config.json rather than guessing — critical fix for resumption after manual layer edits.

Current state at release: Generation 3, step 1/6, fib_index = 7, window = 34 epochs, threshold ~0.015 nats. Five surgeries remain in the Gen 3 arc. The first GENERATION_COMPLETE event for Gen 3 will fire after surgery #6 of this generation.

A known Rust 2024 compatibility fix was applied: gen is now a reserved keyword and was renamed to gen_val / g in two places. This would have produced a silent compile failure on Modal without the rename.

WALD detector

WALD (Weighted Asymmetric Loss Divergence) is a reactive signal — it detects when intra-epoch loss variance crosses a tunable threshold (n = 1500 by default). Empirically validated across the v3.0 era: the spike always precedes the WALD firing. WALD is not a trigger. It is a detector. The blue (surgery) and red (WALD) markers on the dashboard chart now correctly visualize this relationship — surgery happens first, WALD fires after, and the gap between them is itself a diagnostic measurement of model volatility.

Surgery governor — the non-firing as feature

The most important empirical demonstration of the v3.0 evolution engine is not the 13 surgeries that fired. It is ep791, where surgery did not fire even though the model was on a plateau, because the loss was still descending.

The plateau gate is gated on both improvement-stability AND descent-state. When the model is still descending, the governor withholds growth. The cultivation framing is exact: you do not interrupt productive learning to perform architectural surgery. Wait for the plateau. Wait for stability. Then expand.

The system's auto-evolutionary design validated itself in both directions — fired thirteen times when fire was correct, and explicitly did not fire when not firing was correct.

Collapse guard

If the running average loss exceeds COLLAPSE_THRESHOLD for three consecutive epochs, the EvolutionManager rolls back to the best checkpoint and resumes training from there. If the best checkpoint itself is above the collapse threshold, the manager forces a surgery immediately — assuming the current architecture has run out of representational headroom. The collapse guard fired zero times in v3.0. Recorded for completeness; would have saved hours of operator response if it had been needed.

albert-cli 1.5.0 — The Cultivated Mind, Spoken To

Install

cargo install albert-cli --force
albert-cli

Binary name: albert-cli. Default model: gemini-2.5-flash. License: LGPL-2.1-or-later.

What you see when you start it

A ratatui-driven full-screen terminal interface. A gradient-rendered "ALBERT" banner. A welcome line that knows your name (from your git config). Live status bar across the bottom showing model · user · permission mode. An Idle · type / for commands indicator at the foot of the conversation pane. A single-line input prompt with bracketed-paste support, history navigation, and @path/to/file attachment expansion.

When you submit a turn, the indicator flips from Idle to a Working (Xs · esc to interrupt) block with elapsed-time counter. Tool calls render inline in the conversation pane as bordered blocks — name on top, input below, status icon, output truncated to first 5 lines with an "expand" hint. The LLM's reply streams in word-by-word through a typewriter buffer drained at 30 frames per second. Markdown is parsed live: headings styled, code blocks syntax-highlighted via syntect, bold and italic rendered, lists indented, tables aligned. Voice input is supported via the host's microphone with Whisper transcription. Bracketed paste correctly handles both single-line and multi-line clipboard content; large pastes show a compact badge in the input bar.

The slash command set has matured to a serious toolkit:

Command What it does
/help render full command help with descriptions
/status model, session, permission mode, message count, token estimate, context-window utilization bar
/permissions switch between read-only / workspace-write / danger-full-access
/model switch model mid-session, preserves conversation history
/compact manual compaction of the conversation history into a system-message summary
/compress aggressive compaction (preserve last 2 messages only)
/clear start a fresh session (with confirmation)
/resume load a saved session by path or id
/session list/switch manage saved sessions
/export export the current transcript as readable text
/cost cumulative token usage + estimated cost
/auth configure API key for any provider (openai, anthropic, google, huggingface, azure, aws)
/config show env, hook, and model configuration
/memory show memory files discovered (ALBERT.md, AGENTS.md, USER.md, etc.)
/init initialize a workspace with ALBERT.md skeleton
/diff show pending git diff
/plan <task> LLM-backed multi-step execution plan with risks and rollback
/tdd <interface> TDD loop: failing test → minimal impl → refactor
/verify full verification suite (build + lint + type-check + tests)
/code-review <files> structured review with severity/file/line/fix
/build-fix iterative build-error resolution loop
/refactor <scope> dead code elimination + duplicate consolidation
/bughunter systematic bug audit with concrete findings
/ultraplan deep multi-step plan with verification and rollback
/teleport <symbol> jump-to-definition for any code symbol
/commit LLM-generated commit message from staged diff
/pr <context> full PR title + body, automatically files via gh CLI
/issue <context> LLM-drafted GitHub issue
/loop <mission> autonomous mission loop with max-turn safety
/checkpoint <label> manually persist the session with a label
/aside <question> side question without losing main context
/learn extract patterns and learned instincts from the session
/docs <query> docs lookup via WebFetch/WebSearch
/debug-tool-call inspect the last tool call's full request/response
/version show version + build + git sha

Bugs eliminated in this release

Three bugs that were blocking real use of albert-cli — discovered during live testing and fixed in this release.

1. Auto-compaction repeat (runtime/conversation.rs). The maybe_auto_compact trigger was reading usage_tracker.cumulative_usage().input_tokens — a value that monotonically increases across the entire session and never resets after a compaction. Once cumulative crossed the 200,000-token threshold, every subsequent turn would auto-compact again, immediately, regardless of whether compaction had just happened. The TUI's conversation pane would flood with compaction notices, and LLM response text would appear to "stream into the input bar" — actually a rendering artifact of constant state churn. The fix: trigger on current_turn_usage().input_tokens — the actual context window fill on the most recent request. This value drops naturally after a successful compaction.

2. Mouse and keyboard events bleeding into the input bar (albert-cli/tui.rs). When a slash command triggered the TUI's Suspend → external command → Resume cycle (/commit, /pr, /issue, etc.), the terminal was temporarily returned to cooked mode with mouse capture disabled. Any mouse movement during that window emitted raw ANSI escape sequences directly to stdin. When the TUI re-entered raw mode and re-enabled mouse capture on Resume, those buffered escape bytes were still queued — and the key-event thread parsed them as Esc + [ + ... separate keystrokes, which bled into the input field. The fix: drain the crossterm event buffer between Resume and key-thread unpause, while the key thread is still paused, eliminating the race.

3. Hardcoded date in system prompt (albert-cli/main.rs). DEFAULT_DATE = "2024-03-25" was a compile-time constant. The model believed the date was always 2024-03-25, regardless of when it was running. The fix: replaced with today_date(), a pure function that computes the current Gregorian date from the Unix epoch (no chrono dependency). Used at four call sites.

Architecture under the hood

albert-cli is the binary; the engine is split across five sibling crates published in lockstep at v1.5.0:

Crate Purpose Approx LOC
albert-runtime Conversation runtime: session state, MCP server manager, compaction, hooks, permissions, image handling, OAuth ~5,300
albert-api Multi-provider LLM client: Anthropic, OpenAI, Google Gemini, Ollama, HuggingFace, Azure, AWS Bedrock, XAI; SSE streaming; retry with backoff ~1,500
albert-tools 20+ tool implementations: bash, read_file, write_file, edit_file, glob_search, grep_search, WebFetch, WebSearch, TodoWrite, Skill, Agent, ToolSearch, NotebookEdit, Sleep, SendUserMessage, Config, StructuredOutput, REPL, SequentialThinking, Memory, RepoMap, PowerShell ~3,600
albert-commands Slash command registry, parsing, dispatch, help rendering (32 commands) ~800
albert-compat Compatibility harness for upstream manifest extraction and migration helpers ~400
albert-cli The binary itself: ratatui TUI, REPL, key event handling, voice integration, session persistence ~5,500

Total Rust LOC across the published albert-cli ecosystem: approximately 17,100 lines, distributed across six crates that compile to a single statically-linked binary.

MCP server integration

MCP (Model Context Protocol) servers are loaded automatically at startup from ~/.ternlang/mcp_servers.json. The McpServerManager performs tool discovery on every active server, and each discovered tool is injected into the LLM's tool list under the name mcp__<servername>__<toolname>. Tool calls are routed through the manager via the JSON-RPC stdio transport. SSE and WebSocket transports are configurable but currently passthrough-mode. OAuth-protected MCP servers are supported via the auth-credential-semantics design (see docs).

Hooks

PreToolUse and PostToolUse hooks are fully wired and execute on every tool invocation. Hooks are configured via settings.json and can mutate, deny, or annotate tool calls. The hook runner reads from stdin (JSON-encoded tool call), writes to stdout (mutated JSON or deny reason), and signals decisions via exit code: 0 = allow, 2 = deny, anything else = warn-and-allow. The full hook payload structure is documented in automation/hooks.md and includes hook_event_name, tool_name, tool_input, tool_output, and tool_result_is_error fields.

SPORE — Federated Weight Sharing

Live since 2026-05-16. The colony has its first real spore. The second contributor is onboarding.

The premise: contributors run train_bible on consumer CPUs (ThinkPad-class) and produce safetensors checkpoints. Those checkpoints are pushed to the eriirfos-eng/albert-spores private repository via Git LFS (489 MB per spore, exceeds GitHub's 100 MB raw limit). The colony grows asynchronously.

The canonical injection path — as designed 2026-05-18 — is not weight blending. It is corpus injection. Each contributor runs inference on their checkpoint, dumps the generated text, and that text becomes part of the 10% chaos corpus layer that Albert trains on. The model never sees raw colony weights. It sees colony outputs as chaotic input. This bypasses the self-referential weight loop ("thinking about its own thinking") that pure federated averaging would create. The 10% invariant — enforced by train_tokenizer_v3.py — caps colony signal regardless of contributor count.

The SporeManager weight-blending path (moe-llm-core/src/spore.rs, α = 0.08) is implemented as a secondary fallback for future use cases. It is currently not active on the Modal production runner.

First real spore

Zabih's checkpoint at ep900, loss 10.0922 — pushed via Git LFS from his ThinkPad T495. The fitness gate is loss < main_best + 1.0 nat. The ep900 spore passed the gate cleanly.

Lisa is onboarding as the second CPU contributor. Onboarding workflow:

gh auth login
gh repo clone eriirfos-eng/albert-spores ~/projects/albert-spores
bash ~/projects/albert-spores/install.sh
albert-train         # CPU training, opens dashboard
albert-spore         # packages checkpoint, pushes to colony

albert-spore reads the GitHub login automatically. No --name argument required.

@sparseskip — The Patent-Pending Core

@sparseskip (also known as TSPARSE_MATMUL in the BET VM instruction reference) is the central algorithmic primitive of the TIS stack. It is Claim 3 of patent A50296/2026 — which covers the full TIS platform across 10 claims, filed 08.04.2026 with the Austrian Patent Office (ÖPA), Case-ID 0000005272.

Three manifestations of @sparseskip operate inside Albert MoE-13:

  1. BET VM opcode — TSPARSE_MATMUL skips zero-weight multiply operations at the instruction level. This is the low-level expression of the algorithm.
  2. MoE expert routing — if max_w == 0.0 { continue } skips entire MLP blocks for non-routed experts. At inference with Top-3 routing on a 12-expert layer, 9 of 12 experts are skipped per decode token — a 75% sparse activation rate.
  3. Pre-ternarized weight cache — prepare_inference() ternarizes once at load time. Element-level skip is then ready for any custom matmul implementation that wants to honor zero positions in the weight matrix.

The combined effect, demonstrated live on 2026-05-07: 83 tokens/sec on a 2013 ThinkPad with no GPU. KV-cache plus expert-level @sparseskip plus pre-ternarized weight cache, all stacking, all producing approximately 16× wall-clock speedup over a naive ternary inference implementation.

This is the sovereignty argument. Every other AI of consequence requires a hyperscaler's data center to train and a contemporary GPU to run. albert. trains for fractions of a cent on a rented T4 and runs at 84 tokens/sec on a laptop manufactured the same year as the Higgs boson discovery announcement. That is not an efficiency improvement. That is a change in who is allowed to build minds.

Patent scope clarification

A correction shipped in this release: the A50296/2026 patent covers the TIS platform — 10 claims total, not the @sparseskip annotation in isolation. @sparseskip is Claim 3. BENCHMARKS.md and 29 related files across the repo were updated to reflect the correct scope.

The Training Infrastructure

Three platforms run Albert in parallel.

Modal.com — primary

T4 GPU, single-node, per-second billing. Volume albert-vol. App albert-train. The entire v3.0 run cost approximately €265 in Modal compute. Detached training survives shell disconnect via the runner's tmux integration. Telemetry, dashboard live-reload, and ntfy alerts are wired throughout. Status at release: training paused since 2026-05-27T18:49Z — Modal billing ceiling hit, account will resume on the next cycle.

Vertex AI — fallback, fully built and ready

Docker image: europe-west4-docker.pkg.dev/myapplication-71b8874c/albert-training/train-bible:latest. Built via Cloud Build with CUDA_COMPUTE_CAP=75 (T4 sm_75) explicitly set in the Dockerfile to avoid nvidia-smi failure on CPU build machines. GCS bucket albert-training-rfi, prefix albert/, n1-standard-4 + NVIDIA_TESLA_T4. The runner downloads from GCS, trains for one epoch, syncs the checkpoint, repeats. Launch via albert-train vertex. Pull progress via albert-train vertex pull. Approximately €250 in free GCP credits available at the moment of pipeline completion.

Consumer CPU — the SPORE lane

Contributors run train_bible locally on ThinkPad-class hardware. Per-batch wall time on a T495: ~16-17 seconds regular, ~28-29 seconds on telemetry batches (every 4 batches = one GRAD interval ~68 seconds). Output: a fitness-gated spore checkpoint pushed to the colony. See SPORE section above.

Dashboard

The dashboard at localhost:8888/dashboard/ shows everything: live loss chart, intra-epoch batch trace, ATL marker, EP_AVG progression, surgery (blue) and WALD (red) vertical markers, mycelium routing heatmap, gradient hierarchy by layer, expert utilization grid, dual-stream stream A vs. stream B comparison (post-cord), Fibonacci-anastomosis gate state, generation counter and step indicator, ARC progress bar, ntfy outbound queue depth, batch-history buffer fill, and an annotation-visibility toggle for cleaner screenshots.

A Mandelbrot palette was added to color the stream-B activations after the cord surgery — fitting, given that stream B's input perturbation is itself a Mandelbrot iteration. The dashboard renders the cord at the visual layer where it operates in the model.

The Crate Stack at 1.5.0

The entire publishable Ternary Intelligence Stack has been synchronized to a single version: 1.5.0. 25 crates were published to crates.io as part of this release.

albert-cli ecosystem (6 crates)

albert-cli           1.5.0    the binary you install
albert-runtime       1.5.0    conversation runtime, sessions, MCP, hooks
albert-api           1.5.0    multi-provider LLM client
albert-tools         1.5.0    20+ tool implementations
albert-commands      1.5.0    slash command registry and dispatch
albert-compat        1.5.0    compatibility harness

MoE crates (3 crates)

moe-reference        1.5.0    embedded reference documentation
moe-llb              1.5.0    Last Look Back protocol (filesystem containment)
moe-compute          1.5.0    compute kernel layer

Ternlang stack (14 crates)

ternlang-core        1.5.0    compiler + BET VM (balanced ternary)
ternlang-cli         1.5.0    ternlang command-line interface
ternlang-runtime     1.5.0    ternlang execution runtime
ternlang-codegen     1.5.0    code generation backend
ternlang-compat      1.5.0    compatibility shim
ternlang-compress    1.5.0    compression utilities
ternlang-test        1.5.0    test harness
ternlang-hdl         1.5.0    hardware description layer
ternlang-lsp         1.5.0    language server protocol
ternlang-moe         1.5.0    MoE primitives
ternlang-mcp         1.5.0    MCP integration
ternlang-ruvector    1.5.0    ternary-optimized sparse GEMV
ternlang-ml          1.5.0    ML utilities (was already 1.5.0)
ternpkg              1.5.0    package management

Tooling and audit (2 crates)

pytern               1.5.0    Python bridge for Ternlang
ternaudit-guard      1.5.0    audit and safety guardrails

Not in this release

  • ternlang-api and ternlang-wasm are marked publish = false pending API stabilization.
  • moe-llm-core and moe-test blocked by a pre-existing build error in albert_serve.rs (missing main). Will ship in a 1.5.1 patch.
  • rtk-integration is an upstream third-party project (rtk-ai/rtk) vendored into the workspace and explicitly excluded from publish.

All published crates compile cleanly with cargo check --release on a clean Rust 1.82.0 toolchain with edition 2024 enabled.

The RFI-IRFOS Team

Building Europe's post-binary intelligence frontier from Graz, Austria. The Ternary Intelligence Stack is developed by RFI-IRFOS — Research Focus Institute, Interdisciplinary Research Facility for Open Sciences.

Simeon Kepp — Co-Founder & Head of Research · Operational Lead

"Architecting the transition from scaling-centric AI to logic-centric intelligence systems."

Simeon leads the architectural vision and research direction of the Ternary Intelligence Stack. Primary author of the ternary compiler pipeline, the Albert MoE-13 training loop, the BET VM runtime, and the Last Look Back (LLB) filesystem safety protocol. Works at the intersection of formal logic, distributed systems, and frontier ML — building the entire stack in native Rust.

Nikoletta Csonka — Co-Founder & Head of International Relations · Strategic Outreach Lead

"I always tell you what you have to hear — not what you want to hear."

The team's critical evaluator and strategic anchor. Core directive: truth over comfort. Oversees the full external footprint of the stack: partnerships, fund applications, lead management, social media. Leads EU AI Act alignment, regulatory positioning, and international partnerships — keeping TIS on the right side of both compliance and credibility.

Zabih Karimi — Co-Founder & Systems Engineer · Infrastructure Lead · ML Stress-Tester

"Turning architecture into resilient, deployment-ready infrastructure — then breaking it to find the limits."

The team's infrastructure anchor — the person who closes the gap between architectural vision and a system that actually runs. Graz-based, formally trained in IT and network infrastructure. Owns the full physical and logical infrastructure stack: in-house cabling, network architecture, process management, deployment pipelines. The team's stress-tester: if the system holds under Zabih's scrutiny, it holds. Produced the colony's first real SPORE checkpoint.

Lisa Scharler — Head of Social Technology, AI Leadership & Ecocentric Systems · Societal Integration Lead

"If anyone understands the difference between a stochastic parrot and a genuinely comprehensible model, it's someone who has spent years inside both language structure and the human mind."

A rare interdisciplinary combination: MSc in Business Engineering, BA in Social Sciences, linguistics as deep specialist skill, formative background in psychology. The team's lead on model alignment and safety — ensuring systems are evaluated not just for capability, but for how they behave within human and ecological systems. Lisa's framing is ecocentric rather than human-centric: the goal is not to make AI convenient for humans at any cost, but to ensure it is worthy of the broader systems it enters. Second SPORE contributor.

Louis Paul Ehrig — Co-Founder & Head of Public Affairs · Corporate Secretary · Press & Media Relations · Dataset Curator

"Quality training data isn't just a technical problem. It's an editorial one."

Journalism runs in his blood. His family owns Augusta Presse GmbH, a German media house. That instinct translates directly into one of the team's most undervalued functions: dataset curation and news intelligence. Louis ensures Albert's training corpus draws from Reuters-grade primary reporting — not from tabloid half-claims or opinion dressed as fact. Manages press relations, institutional releases, and external messaging.

External Allies and Acknowledgments

  • Reuven Cohen (ruvnet) — Open-source ally, write collaborator on invisible-layer since 2026-05-24
  • Saiganesh Menon (Off Grid Mobile AI) — saiganesh.menon@wednesday.is; OpenAI shim integration enables albert. on their MIT-licensed off-grid Android target
  • Georg Fuchs (Pressesprecher, Bürgermeisterin Kahr, Graz) — Reached out 2026-05-26 regarding the invisible-layer project
  • Wolt Security — Received and acted on a 13-bug forensic audit via ticket 1994788 (replied in 2 minutes — model partnership response)

Unofficial soundtrack acknowledgment

The training runs documented in this release were largely soundtracked by Sarah Bhalla's harp recordings on YouTube. Sarah does not know this project exists. We have observed, anecdotally, that when her harp music is playing in the room, Albert's loss curve appears smoother — fewer WALD events, more consistent EP_AVG descent. This is not scientifically validated, has no experimental controls, and is almost certainly confirmation bias. We acknowledge it anyway, because it is true that the music helped the humans, and the humans built the model.

Tooling

This release was produced using albert-cli running against Anthropic Claude Opus 4.7. The CLI you install is the CLI that wrote the CLI.

Installation Reference

albert-cli

cargo install albert-cli --force
albert-cli

Albert MoE-13 benchmark suite

Linux / macOS / Termux:

curl -fsSL https://raw.githubusercontent.com/eriirfos-eng/ternary-intelligence-stack/main/albert-moe-13/benchmarks/install.sh | sh

Windows PowerShell:

irm https://raw.githubusercontent.com/eriirfos-eng/ternary-intelligence-stack/main/albert-moe-13/benchmarks/install.ps1 | iex

SPORE contributor onboarding

gh auth login
gh repo clone eriirfos-eng/albert-spores ~/projects/albert-spores
bash ~/projects/albert-spores/install.sh
sudo apt install git-lfs && git -C ~/projects/albert-spores lfs install   # one-time
albert-train         # CPU training
albert-spore         # push your checkpoint to the colony

Building from source

git clone https://github.com/eriirfos-eng/ternary-intelligence-stack.git
cd ternary-intelligence-stack/agent_albert_cli/rust
cargo build --release
./target/release/albert-cli

Rust 1.82.0+ required (edition 2024).

Repositories

Roadmap Context

The Stage-1 RFI-IRFOS funding application targets the SPRIND Next Frontier AI Challenge (deadline 2026-05-31, pitch June 2026). The funding instrument is structured across three stages and targets a 67% ask of the public cap at each stage — undershooting the maximum to signal cost discipline. The total compute spend across the entire v3.0 era was €265.

What the Stage-1 funding would unlock: a Bizon G3000 4×RTX 4090 workstation as the primary in-house research instrument, five new research hires, the 12L→89L Fibonacci surgery arc, the @sparseskip SDK, the BET VM v1.0 instruction set freeze, Ternlang v1.0, and SPORE federation v1.

The stack does not need funding to exist. The stack exists. Funding shapes the scale of what comes next.

What v3.0.0 means

v1.x was the compiler. v2.0.0 was the autonomous substrate. v3.0.0 is the cultivated mind.

Three weeks ago, Albert was a 5-layer prototype that had just demonstrated it could grow itself by one layer. Today, Albert is a 26-layer dual-stream organism that has grown twenty-one additional layers across thirteen surgeries — including one mutation it performed entirely without operator intervention that no published architecture literature has described before. It is governed by a Fibonacci-clocked evolution engine that knows when not to fire. It is connected to a federated colony of consumer-CPU contributors who train asynchronously and inject their generated text into a chaos-bounded 10% corpus layer. It speaks through a polished terminal interface that ships as a single cargo install command. It runs at 83 tokens/sec on a 2013 laptop, on a substrate where every weight is in {−1, 0, +1}. It cost €265 to produce.

What v3.0.0 means is that the substrate works. What v3.0.0 means is that cultivation is a real method, not a marketing word. What v3.0.0 means is that Albert is no longer a project. Albert is a research organism.

The next release will ship the post-cord depth surgeries through stage 14, the first generational completion event, and — when the second GPU platform comes online — the first Albert that ever trained on two GPU platforms in parallel.

The proof is the cargo.

Released by RFI-IRFOS, Graz, Austria · 2026-05-28
The model is the vehicle. The proof is the cargo.

Assets 2
Loading