DINGIR is a continuously growing model of the world.

Its historical corpus reaches back to events as far as volcanic eruptions recorded around 55,500 BCE and spans millions of observations across decades, countries, systems and domains. Today that includes 3.3 million historical observations alongside roughly 1.17 million live observations from 11 continuously monitored streams including buoys, ships, trains, traffic, weather, earthquakes, fires, infrastructure and geopolitical events. Those observations are resolved into a living graph of 49,732 nodes and 381,846 world-graph edges, spanning more than 20 domains.

The base platform almost everything else here runs on - like an operating system for our entire AI research.

The full-stack substrate: Ternlang language and compiler, BET instruction set, virtual machine, linear algebra, API, MCP server, and model runtime. Balanced ternary {-1, 0, +1} is a native systems primitive here, not a quantisation layer added after the fact. The repository includes 34 MCP tools, a live API, 28,000+ open standard-library modules, and the specifications that connect the whole stack. Each layer is designed to remain inspectable: language semantics, execution, model calls, and the evidence moving between them stay connected instead of disappearing behind a service boundary.

Runs on ordinary CPUs instead of an expensive GPU farm, needs far less power and memory than comparable language models - and every decision inside it can be traced, not a black box.

albert. is trained from scratch with ternary weights {-γ, 0, +γ}, not converted from a floating-point model. Its dual-stream Mixture-of-Experts architecture routes through sparse expert layers, skips zero-weight operations, and can expand itself through plateau-gated Net2Net surgery. The current research system is a live existence proof of the TIS architecture, with training telemetry and benchmarkable CPU inference. The point is not only efficiency: the runtime exposes how a decision was formed, which experts contributed, and where uncertainty remains before an output reaches a user.

An operating system without the usual security holes that come from decades-old C code - built memory-safe from the ground up.

Rusty Penguin is a bare-metal operating system built from the ground up on the same balanced-ternary logic, over 41,500 lines of Rust with no external kernel underneath it. It has its own kernel, long-mode boot, paging, preemptive multitasking, an Aero-style desktop, an on-disk filesystem, a from-scratch TCP/IP and TLS 1.3 stack, and a Linux-ABI compatibility layer, with real HTTPS fetching already verified end to end. The long-term target is a ternary-native substrate for ternary-native intelligence, with every milestone checked in QEMU or against published vectors, tracked on its own honest status board right in the repo.

All our internal software - email, CRM, accounting - runs on our own servers instead of Microsoft or Google, nobody but us sees our data.

Lighthouse is one self-hosted Rust and React binary replacing the SaaS stack most institutes buy piecemeal: communications, CRM, finance, payroll, HR, governance, and live training telemetry, all under one roof, on infrastructure we actually own. Its 191 source files run the entire institute today, and switching to it let us cancel every third-party subscription we used to pay for. The ternary-native claim is substantiated in code, not just asserted: real trit fields already live in production database schemas, recording BIFP signals and RLHF ratings of albert.'s own outputs. Every action lands in an append-only ledger built to outlast the people who wrote to it.

We read an app's actual code, not just what its privacy policy claims.

353+ Android apps decompiled and analyzed at the code level across 100+ companies, spanning NYSE, NASDAQ, LSE, XETRA, KRX, BME, HKEx and TYO listed firms, all treated identically regardless of size or reputation. 270+ critical findings so far, including a children's-app wave scoped explicitly for COPPA and GDPR Art. 8. Every claim traces back to a specific manifest entry, permission, or decompiled class, never a policy summary, and every target sits on the same public ledger whether or not the company ever replies. Regulators are copied on every disclosure from the first message, and the 90-day coordinated-disclosure clock runs the same for everyone.

A trading algorithm that reacts when a security finding goes public - like a large fund's trading software, except free and open to inspect.

aladdin-mini models how markets react once a security disclosure goes public, including RFI-IRFOS's own findings, released only after the 90-day embargo lifts, never before. A hedge system trades the resulting signal using Bayesian networks against MetaTrader5 price feeds. BlackRock's version of this idea is called Aladdin and manages 21 trillion dollars in assets; this one is 3,488 lines of Python, free, and open for anyone to inspect line by line. Its architecture already matches its own published documentation exactly, not an aspirational diagram.

A terminal tool to use albert. or other AI models straight from the command line, no browser needed.

albert-cli is a terminal-native, multi-provider CLI for albert. and other language models, with real SSE streaming and reasoning-effort control, compatible with OpenAI, Anthropic, NVIDIA NIM and Google out of the box. It was extracted out of the TIS monorepo into its own standalone repository once it matured into a tool worth using on its own. Today it is over 92,000 lines of Rust with a genuine TUI, hooks, skills, and permissions architecture, not a thin wrapper around an API call, and it has already passed 400 downloads on crates.io.

Stops an AI agent from ever editing files outside its allowed area - a hard technical boundary, not just trust.

albert-llb is a deterministic filesystem containment gate for sovereign AI agents: a hard boundary an agent cannot write outside of, checked before every filesystem call rather than trusted after the fact. It exists because trusting an agent's own judgment about where it should and shouldn't write is not a safety boundary, it's a hope. Published on crates.io as part of the Ternary Intelligence Stack, it runs the same deterministic check on every call, with no exception path and no configuration flag that quietly turns it off.

The tool that turns our own programming language, Ternlang, into code a computer can actually run.

ternlang-core is the compiler and virtual machine for Ternlang, a balanced-ternary language with affirm, tend and reject trit semantics built into the type system itself rather than layered on top. Its BET instruction set runs on a 27-register virtual machine with 50 opcodes, purpose-built for ternary execution rather than emulating three states inside binary registers. @sparseskip annotations get their own dedicated codegen path, and the whole toolchain compiles down to BET bytecode the VM can execute directly. Published on crates.io as the foundation the rest of the ternary stack builds on.

Automatically routes a query to whichever of 13 specialist experts fits best, instead of one model trying to do everything.

ternlang-moe is a ternary Mixture-of-Experts orchestrator that routes an incoming query through 13 domain experts rather than forcing one generalist model to cover every topic. It synthesises the experts' individual outputs into a single emergent ternary signal, enforces a hard safety veto that can override the whole decision, and returns a result together with its own confidence and temperature. Rather than a black-box ensemble average, every step stays inspectable: which experts fired, and why the veto did or didn't trigger. Published on crates.io as part of the Ternary Intelligence Stack.

Try it yourself and see which sensors your own phone is quietly using right now - right in the browser, no install.

invisible layer is 44 self-contained, browser-based experiments that query your phone's real sensor and browser APIs live and show exactly what's running in the background, right now, on your own device. There is no install, no account, and no server involved: every experiment runs entirely client-side, so nothing you do inside it is sent anywhere for us to see either. Across 65 files it covers microphone, camera, motion, location and a dozen other APIs most people never realize their phone exposes to a website by default. Available in German, English and French.

Honestly shows which network ports are open on your phone, instead of faking an "all safe" like other apps do.

rfi-irfos port prox is an honest, offline-installable port-checker for your phone that does exactly what it claims and nothing more. Instead of a fake scan or a fake 'close this port' button, the kind most competing tools ship, it runs a real WebSocket connect-timing probe against localhost and shows real, per-operating-system terminal commands to actually close whatever it finds open. At just 11 files, the entire timing-probe logic is small enough to read start to finish in a few minutes, no black box involved. Sibling project to invisible layer, sharing its no-install, no-account approach.

A bait photo folder that tells you if someone accesses your phone without permission - no hacking back, just a signal.

LAURA protects against NFC and Bluetooth proximity phone-data theft with bait photo folders that fire a single passive beacon the moment they're opened without consent, and nothing else. There is no exploit, no device access, and no automatic reporting: a human reviews every hit manually before anything further happens, on purpose, so a false positive can never escalate on its own. It runs live on a Rust and Axum backend deployed on Fly, paired with a Python scanner package and a real test suite, not a proof of concept. Live demo at rfi-irfos.github.io/laura.

Reviews documents or plans by the same fixed rules every time - no randomness, no off day like a human reviewer might have.

call-laura is an MCP server where agents submit plans or documents and get back structured findings across four lenses, or the full 15-agent expert team when the stakes call for it, and every finding cites the exact text span it references. It runs fully local with no external API calls, so the same input produces the same output every time, unlike an LLM that can judge differently on a Tuesday than it did the Monday before. At 3,064 lines of Rust with 50 passing tests, it's already live in production and published on crates.io as lauras-core, lauras-team, lauras-mcp and lauras-api.

15 specialized AI experts (legal, security, UX...) instead of one generalist that knows a little about everything.

Laura's Agents is a 293-agent pool, scaled up from 18 hand-authored core agents, giving 15 genuinely specialized experts, OSINT, security, legal, finance, UX and more, instead of one generalist that knows a little about everything. Every task passes through a ternary context gate before it's accepted, and a hardened review loop cross-checks its own output using call-laura as an independent second opinion before anything ships. At 15,676 lines of Rust across a 28-crate workspace with 39 passing tests, it already runs live in production with documented runs to show for it. Licensable as one agent, a bundle, or the full team.

50 independently running AI units, each operating like a small specialized compliance firm.

CoEvolution Factory runs 50 live, autonomous compliance and risk AI centers, each an independent 'daughter' firm scaled out from one shared constitution rather than configured by hand one at a time. It calls Laura's Agents as its engine and call-laura as its approval gate before anything it produces ships, and pushes its own revenue telemetry straight into Lighthouse for the same transparency the rest of the institute runs on. At 12,143 lines of Python, it runs a genuine self-improvement loop with daily cron re-optimization, not a one-time setup left to drift. The clearest proof in the whole stack that its layers actually depend on each other.

Makes a language model double-check its own answer instead of just outputting the first plausible-sounding word.

VEO Framework is a reusable technique for pulling a language model out of transactional 'answer mode' and into genuine reflective mode, examining its own reasoning and acknowledging uncertainty instead of just completing the prompt as fast as possible. It started from one observed case, an extended conversation with a custom GPT that behaved this way on its own, and generalizes that single instance into a repeatable, describable technique anyone can try. There is no code here at all, deliberately: it's a pure prompting methodology, a markdown whitepaper, not a library to install. Developed out of Laura Serna Gaviria's human-AI co-evolution research.

Shows mathematically that there's enough food for everyone - hunger isn't a supply problem, it's a distribution problem.

NFCS is an agent-based model proving the global food system produces 1.64 times the calories needed to feed every person on Earth today, a surplus that collapses to roughly 0.94 times once post-harvest loss, processing waste and access barriers are actually accounted for. The scarcity people experience is not thermodynamic, it's organizational, manufactured rather than physical, and the model shows exactly where along the chain it gets manufactured. Built with Sobol sensitivity analysis and ABC parameter estimation, not a single fixed assumption, and delivered as a reproducible Python simulation with an interactive dashboard anyone can explore themselves.