THE LAST
PLATFORM

biRT · Bare Metal Intelligent Runtime

Pick the hardware. State your intent. Ship it.
We generate the hardware-specific runtime and the manifest that drives it. Change behavior by talking to NOUS, our platform's brain. The runtime never recompiles.

▾
Getting Started

THREE STEPS TO SHIPPING.

From the operator's first sentence to a live system. Three steps. Three industries below — same path.

1 · Pick → 2 · State → 3 · Ship
1 · Pick the hardware
biRT runs on a runtime host you provide — typically a small GCP VM, scaled to your site. The host carries the intent; the operator-facing devices already in the building connect over the local mesh. No new operator-side hardware to buy.
2 · State your intent (operator to NOUS)
“I run a 60-seat dine-in. Take my menu, route orders from the front to the kitchen, settle checks at the table. We're open 11 to 10.”
3 · Ship (NOUS confirms)
“Manifest signed and broadcast over the local mesh to the phone-KDS and POS tablets. Applied at next tick. Dine-in is live — speak any name change for any item or hour any time.”
1 · Pick the hardware
One GCP ELITE-tier compute instance (c2-standard-8) for the plant-wide controller — bulk translation, manifest broadcast, alert routing all on the metal. Each line station's existing operator hardware connects over the mesh.
2 · State your intent (operator to NOUS)
“Five lines, plant A. Track throughput. Alert me when any line drops below target by 10%. If a line slows, route surplus to lines with headroom. Shift starts 6am.”
3 · Ship (NOUS confirms)
“Manifest signed and broadcast from the controller to every line phone. Applied at next tick. Throughput board is live — speak any new threshold any time and I redeploy.”
1 · Pick the hardware
biRT runs on a runtime host in dispatch — a GCP VM or a local x86 controller, your call. Field crews carry whatever ARM hardware your team already standardizes on as the mesh terminal: biRT-A on the device when the bootloader is locked, biRT bare metal when it isn't. They mesh over BLE, LoRa, WiFi, and serial.
2 · State your intent (operator to NOUS)
“Dispatch jobs by zip. Page the storm-response team on weather alerts. Suppress non-emergency tickets in active storm zones until the all-clear.”
3 · Ship (NOUS confirms)
“Manifest signed and broadcast across the mesh. Applied at next tick. Dispatchers see the new routing now. Crews stay in sync without cloud uptime.”

Three steps. Three industries. Same path.

The Cost Question

THE FIRST 90 DAYS.

Honest answer: we don't know yet. Honest prediction: less than 90 days.

The typical platform onboarding is a long chain of translators. What your operators want has to pass through engineers, architects, vendors, deployment teams, QA, and back to the operators again. Every link slows the work. Every link dilutes the original intent.

We collapse that chain. The operator states the WHAT in plain language. NOUS and the-last-platform deliver the HOW — directly, on the metal. That is the source of the speed.

Honest disclosure. No external operator has shipped on this in production yet. The "less than 90 days" prediction is grounded in internal use across multiple deployments, not third-party measurement. We will publish real numbers the first time a customer ships.

The Platform

biRT is a complete computing platform written from scratch in C. It runs directly on hardware. No operating system, no kernel, no filesystem, no external libraries.

One binary. Direct hardware access. From power-on to thinking in under a millisecond. biRT lands on any hardware that doesn't lock the boot chain after BIOS. Two GCP VM tiers run biRT bare metal in production today — ELITE compute (c2-standard-8) and FOUNDATION catalog (e2-micro), six nodes across three continents. ARM bring-up runs on consumer phones where the bootloader is reachable; where it isn't, biRT-A ships the same intent contract as an Android-form runtime until the device unlocks. RISC and other architectures are next, on the recommendation of our hardware engineer Norman Campbell.

Because the runtime is pure machine code and small enough to fit beside the silicon — not on top of a half-gigabyte of operating-system overhead — the hardware does what it was built for. The OS isn't in the way.

Data Sovereignty

YOUR KEYS. YOUR DATA. ON YOUR HARDWARE.

Cryptographic keys are generated on the device and never transmitted off it. Local storage is sealed with passphrase-derived keys (PBKDF2). Brute-force lockout is built into the vault. Anything in transit is wrapped in AES-256-GCM. Anything at rest is wrapped in AES-256-GCM. Authentication uses Ed25519 signatures, implemented from finite-field arithmetic up — no library shortcuts.

This is what we have shipped, in the codebase, today. The conversational privacy layer for AI interactions — the part that mediates between operators and external models — is being designed now. We will describe it on this page when we can point at running code.

Your Keys. Your Data. Your Hardware.

What It Does

Pure Intent → Runtime
Describe what a system should do; get a runtime that does it. Today, our builders and craftspeople use the tools to produce the pure intent the runtime executes. Tomorrow, that power moves to the operators — the people who know the task better than anyone.
Target Anywhere
Two GCP VM tiers run biRT bare metal in production — ELITE compute and FOUNDATION catalog, six nodes worldwide. ARM bring-up where the post-BIOS chain unlocks; biRT-A on Android where it doesn't. RISC and emerging architectures next, on the recommendation of our hardware engineer. The same intent compiles to whichever target you choose.
Direct to Hardware
No operating system between the runtime and the silicon. Power, registers, peripherals, sensors — addressed directly. You get the hardware you actually paid for, not what an OS leaves behind.
Encrypted & Sealed
Strong primitives. Sealed local storage. Brute-force resistance. Keys generated on the device and never transmitted off it. Privacy is structural, not a setting toggled on later.
Mesh & Offline
Devices find each other and talk securely without cloud infrastructure. Store-and-forward across LoRa, Bluetooth, WiFi, and serial. The system keeps working when the network doesn't.
Built-In Intelligence
Natural-language understanding, query reasoning, multi-format ingestion (PDF, JSON, CSV, plain text), and a 155,000+ word lexical database — running directly on the runtime, not as a cloud call. External AI services are tools, not dependencies.
How Behavior Changes

BEHAVIOR IS A CONVERSATION.

The runtime is small, fast, and stable. Behavior is the manifest — a deployment-specific description of what the runtime should do, on which targets, and when. Change the behavior by changing the manifest. The runtime never recompiles. The conversational and authoring layers above this are in active development; the example below is illustrative of the design, not a transcript from a production system today.

Operators don't write code to change behavior. They have a conversation with NOUS — our platform's brain. NOUS turns the conversation into pure intent — expressed in BASICI — and ships it as a signed manifest the runtime can execute. Any human language in. BASICI out. The runtime stays the same.

Conversation → Pure Intent → Manifest → Runtime
Operator says (to NOUS)
“Hey NOUS, we're closing the second grill station for maintenance — should be back up in a few days. Push grill-2 orders over to grill-1, prioritize salads and bowls on the kitchen displays, and have the front-of-house gently steer guests away from grill-heavy items until I tell you we're back.”
NOUS drafts the manifest from pure intent
Scope:kitchen-display + POS + FOH-tablet runtimes (this site)
Active:now → until operator says otherwise
Reroute:grill_2 orders → grill_1
Priority:salads + bowls, surfaced first on KDS
FOH hint:recommend non-grill items in suggestion module
Revert:operator says “grill 2 is back”
Operator confirms
“That's it. Go.”
What happens
Signed manifest goes out over the mesh to every runtime in the building — KDS, POS terminals, FOH tablets. Applied at the next sync tick. No code shipped. No restart. No outage. Reverted just as fast when the operator says it's back.
Operator says (to NOUS)
“NOUS, line 3 is running half speed today — QA is sampling. Don't trip the under-throughput alert, and route the surplus to lines 4 and 5 if they have headroom. End of shift, go back to normal.”
NOUS drafts the manifest from pure intent
Scope:production-line runtimes 1–5 (plant A)
Active:now → end of today's shift
Threshold:line_3 throughput floor lowered to 600/hr (was 1200/hr)
Routing:line_3 surplus → line_4 + line_5, cap 200/hr each
Fallback:local buffer if 4 or 5 are at capacity
Revert:shift end OR operator says “line 3 back to normal”
Operator confirms
“Looks right. Send it.”
What happens
Manifest signed and broadcast to all five line runtimes. Applied at next tick. Alert thresholds shift; routing kicks in only if 4 and 5 have capacity. The runtimes themselves do not change. Auto-reverts at shift end.
Operator says (to NOUS)
“NOUS, the storm is hitting the southern region. Postpone all non-emergency dispatches in zip 30500–33999 for the next 12 hours. If anyone in that area calls about an active outage, page the storm-response team instead of the regular crew.”
NOUS drafts the manifest from pure intent
Scope:dispatch + customer-portal runtimes
Active:now → +12 h (auto-revert)
Region:zip 30500–33999
Filter:non-emergency tickets → defer queue
Route:emergency / outage tickets → storm_response group
Revert:12-hour timer OR operator says “storm cleared”
Operator confirms
“Yes. Go.”
What happens
Manifest pushes to dispatch and customer-portal runtimes across the affected region. Applied immediately. Auto-reverts in 12 hours unless extended. No code changes anywhere.

Two worlds, joined: single-purpose machine-level code that runs as fast as the silicon allows, and human thought translated into runtime instructions by NOUS. The runtime never sees the conversation; the conversation never has to know about the runtime.

Our Language

BASIC INTELLIGENCE.

BASICI is the language pure intent is written in. Not the old IBM BASIC. Not a tutorial language. The AI version — canonical, unambiguous, hardware-aware.

Like assembly, in spirit.
Compact. Unambiguous. One operator per logical relationship. No synonyms. No surface decoration. Reads like x86 assembly or BASIC-A reads to the people who already know them — tight enough to trust.
Built to translate.
Designed to capture meaning across human and programming languages alike, then reduce it to pure intent. Surface tokens change; the logic does not. Roundtrips between C, BASICI, and natural language are validated by ~50,000 lines of translation proofs across every Intelligence skill.
Hardware-aware on the way out.
The same intent compiles to whichever target the manifest names. Two GCP VM tiers (x86) plus ARM phones where the boot chain unlocks. RISC and emerging architectures next. The translator handles the hardware specifics so the operator never has to.
Portability is the goal.
Our north star: every intent expressed in BASICI serviceable by every runtime we generate. One manifest, every target. Today the cross-skill roundtrip is proven; cross-target portability hardens as each new architecture lands.

An operator speaks to NOUS in their own language. NOUS generates and deploys the new intent to the runtime, confirms successful operation, then responds to the operator in their language, dialect, and style.

Intelligent Data Store

Memory-mapped. Journaled. Encrypted at rest. Public benchmarks coming.

The memory layer is memory-mapped (zero-copy), journaled for crash safety, encrypted at rest with AES-256-GCM, and indexed by up to 16 keys per store. Binary serialization compresses roughly 79x versus raw text. Knowledge and code share the same representation, which means the system reasons about its own behavior the same way it reasons about anything else.

Internal seek-speed measurements are very promising. We will not claim "fastest on Earth" until we have published the numbers. We are running the architecture against Wikipedia and other public datasets next, and the benchmarks — methodology, hardware, raw numbers, comparisons — will be published in full and reproducible by anyone who wants to verify them.

Benchmarks · Coming · Public · Reproducible

What We Do

We turn pure intent into a runtime that runs on your hardware, under your keys.

What We Can't Do Yet

Some pieces are not finished. We are not going to pretend otherwise.

Capability Ledger

CapabilityStatusWhat it means
biRT on consumer ARM phones (where the boot chain unlocks) Shipped Bare-metal bring-up on consumer ARM phones where the post-BIOS chain hands off — boots through the device's bootloader to biRT, no OS. Framebuffer, debug, sensors, runtime all on the metal. The proof that biRT lands wherever the bootloader is reachable; per-device bring-up clears each new vendor's chain.
biRT-A — Android-form runtime Shipped When a device's bootloader is locked and the unlock path is exhausted, biRT-A ships the same intent contract as a single Android kiosk app — fullscreen AMOLED, all hardware sensors via SensorManager, identical 16-byte event log. When the device unlocks, the bare-metal binary takes over. Until then, biRT-A is what runs.
biRT on GCP — ELITE + FOUNDATION (x86) Shipped Two VM tiers running biRT bare metal in production, six nodes across three continents. ELITE (c2-standard-8) handles bulk translation, repo import, mesh hubs. FOUNDATION (e2-micro) serves encrypted triples at the edge. From-scratch gVNIC driver, UDP/IP/DHCP/ARP, bare-metal libc replacement, HW-accelerated crypto (AES-NI, SHA-NI) with software fallback.
Intelligence stack Shipped Natural-language understanding, reasoning, multi-format ingestion (PDF, JSON, CSV, plain text), intent ingestion with multi-source corroboration, 155,000+ word lexical database. ~28,000 lines of production C.
Cryptographic primitives Shipped AES-256-GCM, SHA-256/512/1, HMAC, PBKDF2, Ed25519 implemented from finite-field arithmetic up. Authentication uses constant-time comparison — no timing side channels.
Console & QR provisioning Shipped Cross-platform interactive terminal with F-key command bar (search, try, feed, confirm, ship, refactor, trace, save, inspect). QR generation from scratch (Galois field GF(256), Reed-Solomon error correction) for scan-to-register device provisioning.
Translation proofs (BASICI) Shipped ~50,000 lines of validated roundtrips proving every Intelligence skill survives translation between C, BASICI, and natural language. The receipts behind the BASICI claim.
Operator console for AI (metal console) Drafting Operator-facing console that mediates AI conversations and authors manifests. Designed; planned and scoped in the metal repo. Not yet running end-to-end.
Multi-AI desktop edition Drafting Single surface routing to multiple popular AI providers. Designed; not yet built. Will not be claimed shipped until anonymization behavior is implemented and demonstrated.
Noise On The Wire (NOTW) Shipped Core protocol, mesh, and relay are done. Discovery, routing, store-and-forward, AES-256-GCM transport encryption, cross-platform. Additional transport backends (BLE, LoRa, WiFi/UDP, serial) being added.
Intelligent Data Store (IDS) Shipped Memory-mapped, journaled, encrypted at rest, indexed for sub-microsecond seek. Tested across persistence, growth, scope, and journaling. Wikipedia-scale public benchmarks pending; the architecture itself is done.
Pure-intent authoring tools In Progress Engineers can author and edit intents directly. End-user authoring (no engineer required) still in development.
Conversational manifest authoring Drafting Operators describe behavior changes in plain language; the system drafts a signed manifest. AI-assisted, multi-language. Designed and scoped; not yet running end-to-end.
Manifest delivery over mesh In Progress Signed payload broadcast over the mesh, applied at next runtime tick. The transport, signing, and broadcast paths are shipped; manifest-as-runtime-config is in active integration.
biRT on RISC and emerging architectures Drafting Architectural targets identified with our hardware engineer. Bring-up work not yet started.
Custom silicon Not Yet Direction, not deliverable. Stated for honesty, not as a commitment.
External operator deployments Not Yet Internal use across multiple repos. No third-party in production yet.
One More Thing

WE BUILD THE PLATFORM ON THE PLATFORM.

The Last Platform is being used to build The Last Platform. The system reasons about itself, updates itself, and is being built to repair, and ship itself end-to-end. Today a human still pulls the final lever on every release. Tomorrow we don't.

This is what a complete AI-native company looks like — first of its kind in the AI renaissance. Not a wrapper around someone else's model. Not a thin orchestration layer over the existing stack. Bare metal up, runtime up, intelligence up — every layer ours, every layer auditable, every layer composable.

Anyone not throwing everything away and starting from nothing is doing it wrong. Goodtimes.