Operating Intelligence — a sovereign agent operating system.
Fibre is a sovereign, microkernel agent operating system — an Operating Intelligence System that runs a person’s digital life and a company’s operations on hardware they own. It is not a chatbot, a copilot, or a wrapper around a frontier model. What we sell is an organization rather than a model: a standing team of roughly 400 authored professional competences that occupy domains, run multi-step processes, hold deadlines and duties, and act with governed autonomy. Which model runs underneath is a background operational knob, never a pricing tier. Customers differ along four dials — how many domains are lit, how senior the workers are, whether work serves a personal or business book, and who else can see inside — rather than by buying four products. A structural commitment sits underneath, enforced as a build-time gate: capability is never withheld by price tier. The cheapest subscriber still gets consults, escalations, and briefings; they buy fewer domains at lower seniority, never a deliberately degraded machine.
One sentence generates every architectural boundary in the system: data and discovery never leave the node, and only explicit outbound actions reach the network. Understanding is local; the system reaches out to act, never to aggregate. Three consequences follow, each structural rather than a promise. There is no way to hold a customer hostage, because their data plane already lives on their hardware — leaving means keeping your node, not exporting from someone’s cloud. Compute and state are separated, so everything the system learned about you is ownable and never trapped inside the engine. And sovereignty is the compliance story: for clinical, legal, financial, and government buyers, “the data physically never left the building” beats any certification about how a vendor handles data in their cloud. This runs on a home node holding the models, memory, secrets, and every network-touching capability. Thin devices hold none of those, and the code is self-hosted — the canonical git origin is the home node, with no GitHub dependency anywhere.
Business software fragments the operator into a dozen systems of record that each own a slice of reality and none of which own the work, leaving humans as the integration layer and their attention as the bottleneck. AI assistants are stateless and shallow: a chat window with retrieval bolted on has no durable memory of your operation, no concept of a process that must complete, no accountability for a deadline, and no authority model for acting on your behalf. Vertical AI compounds this by forking the engine, welding domain knowledge into application code so each new industry becomes a new company. Buyers are told sovereignty and capability are a trade-off. Four things converged to make the alternative viable: open-weight models became good enough to run on a box in a house, agentic autonomy arrived with no shared answer for authority or audit or a kill switch, data-residency pressure began turning sovereignty into a procurement advantage, and ambient hardware got cheap precisely because the intelligence can live at home.
Fibre is decomposed into organs — each its own repository with a single role, all speaking one shared contract layer. Organs depend inward on those contracts, never sideways on each other, and because boundaries are proven by inert schemas rather than network hops, the separation costs no latency. A host and fortress owns transport and the single outbound authorization chokepoint. A microkernel wires the organs and runs turns. A zero-dependency law organ holds policy, mandates, audit, and kill authority. A product organ carries the operating model and the sellable shelf; a domain layer supplies industry knowledge as declarations; an append-only data plane holds memory and recall; an edge organ gives one device runtime many hardware faces; a meta-brain assesses the situation and proposes work; and a recognition sidecar identifies faces and voices locally. Nine organs were reviewed in depth, totalling roughly 652,000 lines of production Python plus edge firmware, a React front end, and several hundred architecture documents. The authored operating model alone holds 394 specialties, 99 processes, and 162 entity types.
Sovereignty by architecture sits at the top, because a competitor cannot retrofit it onto a cloud product — it requires designing every seam around it from the beginning. Next is the roughly 400 authored competences with their tool grants, routing anchors, autonomy contracts, and quality bars: accumulated domain judgment is the slowest asset in this category to reproduce, and a better model does not produce it for you. Third, the domain-blind kernel with declarative verticals means one codebase serves every industry, so time-to-new-vertical is a content project. Fourth, the authority layer makes authorization injection-proof by construction — the code that decides never reads model-visible text — with mandate-scoped autonomy, absolute kill, and vendor independence enforced at the syntax-tree level. Fifth, autonomy is earned: freedom of action per decision class is computed from the human’s own approval history, gated on a conservative statistical bound, demoted immediately on reversal, and capped so the system can never propose silent autonomy for itself. Below those sit 71-plus conformance gates that block boot, making architectural drift a build failure; records that outlive workers, so firing an AI never touches the books; and a device runtime that makes a microcontroller and a desktop provably the same product.
Running in production today: the host launching the full stack, the authorization chokepoint with 50-plus dependent files, the unified human decision queue, the edge wire contract, telephony with sovereign local speech, full ambient voice turns on microcontroller-class hardware, Raspberry Pi device faces in kiosk deployment, and the recognition sidecar validated on real photographs and household audio. Proven by test: durable execution with transactional outbox, idempotency, and crash recovery via log replay; replay parity across both data planes; the security decision pipeline; import boundaries and conformance gates; and the earned-autonomy ladder across 120 passing tests. Genuinely in flight, and worth stating plainly because presenting it well builds credibility with a technical acquirer: the host migration off the legacy orchestrator is mid-stream against a published parity checklist, the operating loop is phased and partly landed, security gates beyond the first two are specified but unimplemented, full-suite CI is not green in a bare workspace, and the biometric compliance program — consent capture, retention schedule, encryption at rest, liveness — is a scoped gap rather than something built. On that last point, recognition is safe to market as presence and personalization, and must not be marketed as authentication.
Declared content already serves eight segments: business operations, clinics, law firms, venture funds, logistics, marketing organizations, public sector, and households. Because each vertical is a manifest rather than a codebase, the engineering cost of the eighth industry approaches the cost of the second — inverting the usual vertical-SaaS economics where every new industry demands a new product team. Three wedges are defensible, and any can lead depending on audience: regulated professional practices, where sovereignty converts directly into procurement advantage; small-business operations, where the buyer needs an entire back office and cannot hire one; and sovereign or defense deployment, where denied cloud egress, signed audit, boot attestation, and full-freeze kill are requirements no cloud-native vendor can meet. Revenue surfaces already exist architecturally across subscriptions, executive seats, vertical overlays, hardware appliances, the home node itself, and edge and defense licensing. Two facts strengthen unit economics: inference is largely local, displacing competitors’ dominant marginal cost onto customer-owned hardware, and new industries are declarations, so gross margin does not degrade as the vertical count grows.
The convergence above sets the conditions; the timing argument is narrower than that. Value in this category is migrating away from the model and toward whatever layer holds memory, authority, and the device — and layers like that get chosen once, then hold for a decade. That choice is being made now, under a specific constraint: agentic deployment is stalling on authority and audit rather than on capability, and the system that answers those structurally becomes the default rather than one more competitor. Meanwhile the entrants who would otherwise close the window cannot reach it from where they stand. Sovereignty cannot be retrofitted onto a cloud product. The frontier labs are building minds, not the body a mind has to live in. The hardware incumbents have no authored operating model to run on the box. What is unusual about this entry point is which risk is already retired: the question is not whether the architecture works. Roughly 652,000 lines run on real hardware today — boundary-enforced, conformance-gated, with crash recovery, replay parity, and audited authority. Capital buys completion and distribution rather than discovery. It finishes the host migration and the operating loop, implements the remaining security gates and attestation for enterprise and defense qualification, hardens two device faces to production, and seeds the first vertical go-to-market. This is pre-revenue technology and domain intellectual property, and it should be framed that way. What it is not is a demo, a wrapper, or a bet on a model getting better. It is the layer underneath all of that, already built — and the window in which that head start still counts is the one we are in.
Fibre Research Labs Inc. © 2026