Every sentence a business speaks is made of the same seven parts — someone, doing something, to something, with properties, under rules, leaving a record, inside a world. We build software that forgets this, product after product. The Vinxi Kernel is the operating system that remembers it once — so every product, every dashboard, every AI agent, and every customer's bespoke reality runs on the same small, governed core.
Before any vocabulary, look at what actually breaks. These are real shapes of failure from our own products — click each one.
Four different products, one root cause: every system rebuilds, from scratch, its own answer to the same five questions. What exists? Who may change it? What happened? What if? And how do we know what's true when sources disagree? Because each product answers privately, nothing is shared — not the security model, not the audit trail, not the simulation machinery, not the agent safety story. Every feature is paid for N times, and every product gets a slightly worse version.
An OS kernel manages one scarce resource — the machine — and forces every program through one mediated interface to touch it. Programs don't write to disk sectors; they make syscalls. Drivers hide messy devices behind one contract. Protection rings make a million untrusted programs safe on one machine.
Now swap the hardware. Roads, fiber routes, and market territories instead of RAM. Field engineers, dashboards, and AI agents instead of processes. Stripe, Google's traffic feed, a CCTV camera, and a Proxmox cluster instead of peripherals — each needing a device driver. And the kernel's job, in plain words, is four things: one living picture of everything you operate, fused from every source and honest when they disagree; one gate for change, through which every action — human, system, or AI — is permission-checked and recorded; one unbroken story of who did what, when, on what evidence; and one rehearsal space, where you copy the world and try the change before the real world feels it. (Engineers compress all four into one sentence — the kernel manages coherent truth about reality and the right to change it — but the four jobs are what that sentence means.)
That last line is the whole trick. The kernel is thin but not empty — it understands the grammar of reality-modeling without knowing any specific reality. "A cable connects to a joint" isn't kernel code; it's a customer's declaration expressed in the kernel's primitives, the way your program is just data to a CPU. One kernel binary, N realities loaded into it. That's why the sentence at the top of this page works for four completely different products — and why the operating system we ship a customer is kernel + their userland: theirs and only theirs.
Everything any program — or agent — can ever do to reality reduces to six verbs. Two wake your code up; four are the only ways to touch the world. Click each.
Why six and not one generic "write"? Because the kernel must know — statically, from the verb alone — three things: is this replayable in a simulation, does it belong on the audit spine, and does it leave our universe. A decision (Act) replays; a sensor reading (Assert) is torrential and never replays; a call to Stripe (Call) is irreversible — a simulation must never re-run it. Collapse these into one verb and simulation either corrupts the real world or becomes impossible. The verb split isn't taxonomy; it's what makes what-if safe.
Most systems store road.speed = 42 and silently discard whichever sources disagreed. We store a resolved value: the fused number plus its uncertainty, its evidence, and — critically — whether the sources actually agree. Try it: toggle the sources feeding one road segment.
Because decisions live on an ordered log and state is snapshotted, a "what-if" is a copy-on-write branch of reality: clone the snapshot, replay the intervention, run the engines, diff against the real city. Decisions replay into the branch; external calls are stubbed — a simulation can never phone the outside world. Toggle the intervention:
Underneath, one store never does everything (the lesson of Palantir's own V1→V2 rebuild). Process is where decisions are authorized and committed. Truth is the append-only history — a family of logs, and the audit trail falls out of it for free. World is the coherent, fused, branchable interpretation. Serving is fast derived indexes — rebuildable, authoritative for nothing. Materialization is the machinery that keeps them all current. The log is truth of history; Process is truth of action; World is truth of interpretation; Serving is truth of nothing.
An AI agent is just an Actor. Its code runs in a sandbox whose only vocabulary for touching the world is the six verbs — it holds no database handle, no credentials, no sockets. It literally cannot express an ungoverned effect. Prompt injection can change what an agent wants; it cannot grant a capability the agent doesn't hold. The same governance fires at three moments, earliest to last:
And the tool surface agents use isn't hand-written: it's generated from the live ontology — the same projection that makes the typed SDK also emits the agent's tools. A sub-agent receives an attenuated capability token, mathematically narrower than its parent's. Authority only ever shrinks down an agent tree.
The kernel depends on ~24 ports — narrow contracts like "transactional state," "ordered log," "sandbox," "capability token." Each is filled by a swappable adapter. The test that a port is drawn correctly: swapping its adapter is invisible above the seam. Switch the profile and watch the technology change while the architecture doesn't:
| Port | Contract (fixed) | Adapter (moves) |
|---|
Half our market — telecom, utilities, government — requires on-prem or fully air-gapped deployment. This architecture treats deployment mode as an adapter choice: open storage formats, offline-verifiable security tokens, and pull-based delivery of cryptographically signed release bundles across the gap. The same kernel that runs as SaaS runs inside a customer's disconnected network. That is a capability almost nobody selling into our sectors can honestly claim.
These four aren't just beneficiaries — they're deliberately chosen because each one maxes out a different axis. If the kernel survives all four, it survives the domain.
Why now. Three curves crossed at once. AI agents became capable enough to do real operational work — and dangerous enough that ungoverned architectures can't host them; whoever offers governed agency wins the enterprise. Second, the pattern is proven at the high end: Palantir built a $100B+ business on exactly this shape — ontology, governed actions, derived indexes, generated SDKs — but closed, heavyweight, and priced for governments. Third, the open-source substrate (open lakehouses, WASM sandboxes, Zanzibar-style authorization, capability tokens) matured to where a 50-engineer company can assemble what only a 4,000-engineer company could build five years ago. Our version is smaller, open-format, air-gap-native, stronger on operational action and contested truth — and agent-native from the first commit.
What we're asking for. Commitment to the kernel as a first-class product — not a refactor squeezed between deliveries. The build sequence is deliberately boring: the Lean column first (Postgres, an outbox, a log, custom materializers, one generated SDK), proven against one product's real workload, then graduated port by port on evidence. The moat at the end is not any technology on the board — every adapter is replaceable. The moat is the thing that never swaps: the governed seam, the ontology, the truth/world/process split, and typed userland generated from a customer's own reality.