SMARTHAUS · Investor briefing
You already have an AI fabric. Nobody is governing it.
A fabric is not something you buy. You have one the moment AI is acting across your enterprise, your products and your environment. The question is whether it is governed. We identified every place an AI can act inside a business, and we are building a part for each one. The parts are separate products, each usable without the others, and a first engagement starts at one seam. That span is the point: control that stops at a single application does not govern a fabric.
What we are building
SMARTHAUS builds the mathematically governed AI fabric: rules proved before they run, enforced in the path wherever an AI can act, with a record that survives the argument.
When AI moves from suggesting to acting, an organization needs to know what the system understood, what it was permitted to do, what it consumed, how it reached an executable decision, and what changed as a result. Those responsibilities are currently spread across models, gateways, identity systems, application code, and governance products, and the relationships among them are rebuilt for every application. The fabric makes those relationships explicit and governable.
Two things do the founding work beneath it. Mathematical Autopsy is the construction discipline that formalizes a capability and proves it before code is written, and the Mathematical Autopsy Engine turns a rule written in plain language into a proven, enforceable artifact that keeps its lineage. The Unified Calculus is the shared mathematical foundation every component is built on.
Above that foundation the parts do three things. It converts a request into structured intent and carries that intent, with its constraints, through a plan. It decides at the action boundary whether an action may proceed, before the effect occurs; an effect is the actual change an action makes in a real system, as distinct from what the model proposed. And it preserves state, meaning, and history, so each decision has the context the last one had. Rules and connectors are built upstream, distributed as signed packages through the Marketplace, and ingested, validated, and admitted by the control plane before any application or runtime executes them. The Fabric tab lists every component, what it does, and its current status.
The runtimes, the control plane, and the Operations Center are the products. What they change is whether the fabric a customer already has is governed: each place AI acts, within their own products, internal tools, data, agents, and development tools, decided in the path under proven rules. Each runtime stays connected to the Operations Center, which is how a changed rule reaches it, including a runtime inside software the customer has already shipped. The receipts are the evidence of that coverage.
The model remains probabilistic. The acceptance of its output and the authorization of its actions are deterministic, and each decision produces a receipt.
How work moves through the fabric
One path, with a decision before the effect.
Interface
A request enters through the person’s own assistant.
Intent
The request becomes structured intent; ambiguity is sent back for clarification.
Plan
Intent and its constraints are carried through a plan.
Output
A governed model produces output, checked against the contract for its use.
Action boundary
The action is admitted or refused here, before the effect occurs.
Effect & receipt
The change happens in a real system, and a receipt records the decision.
Memory. One memory preserves state, meaning, and history beneath every step.
Construction. One construction engine, on one mathematical foundation, supplies the rules and their proofs.
The market
Why this is a multibillion-dollar market.
The operating layer is already contested.
AWS made Policy in Bedrock AgentCore generally available in March 2026. Microsoft Agent 365 and OpenAI Frontier both address agent execution and permissions across enterprise systems. Each is a serious entrant with real controls. SMARTHAUS competes on the combination: formally verified rules, customer-controlled enforcement, authority bound to the exact action, and receipts linking every decision back to how the rule was built. The Category tab compares each competitor directly.
Capital is already backing mathematical proof.
Menlo Ventures led Axiom’s $200 million Series A in March 2026 at a valuation above $1.6 billion, on the thesis that AI will write the code and mathematics will prove it works. Axiom proves code. SMARTHAUS proves what an agent may do and enforces it at the point of effect. A verification primitive can be one call inside our construction engine; it cannot decide whether an action is admissible. The Evidence tab holds our formal-methods counts and their exact scope.
The rulebook moved twice in 2026.
On 14 May, Colorado repealed and replaced its own AI Act: Senate Bill 26-189 moved the effective date to 1 January 2027 and narrowed the law to disclosure and transparency. On 27 July, the European Union's Digital Omnibus, Regulation (EU) 2026/1744, deferred the Annex III high-risk obligations to 2 December 2027, and to 2 August 2028 for AI inside products already covered by product-safety law; Article 50 transparency, the general-purpose AI obligations, and the Article 5 prohibitions did not move. Regulations change; the shape of a rule does not. When a clause moves, the affected rule is rewritten as a sentence, re-proved, and delivered to every runtime holding the old one, and nothing is redeployed. That does not tell a customer what a rule should say or make them compliant; it makes the rule they choose enforceable and current.
The outcome comes from recurrence.
Interpretation, coordination, output admission, action authority, and persistent context recur across sales operations, service, finance, research, and software delivery. Two working applications, SIGMA and ECC, already demonstrate the same control pattern, though both still need product-specific integration with the shared fabric. Each new workflow should cost less than the last, because rules, connectors, and evidence packages are reusable assets. We measure that reuse rather than assert it.
The round
$4M seed at a $25M post-money valuation.
$21M pre-money and 16% for new investors, fully diluted. The terms are board approved. Definitive documents and closing remain ahead, and the detailed terms are shared with invited investors.
Leadership
Where each part stands
We mapped the seams. Here is where each part stands.
The map is finished; the parts are staged. We publish the staging before anyone asks, including the parts still on the map and not yet built, because a map that stopped at our own code would not be a map. No part is yet customer accepted; the round is intended to change that.
the action gate — admit, refuse, or ask a person
Universal Control Plane. Five decision behaviours demonstrated on a real machine (allow once, deny, a saved allow reused, revocation, and ask every time), with two different coding agents governed through one plane at the same time.
where the rules are made
Mathematical Autopsy Engine. The engine runs and the method scales: 671 rules across nine regulated domains in a single deterministic campaign, none blocked. They are proposed candidates, held rather than published.
intent — what was asked, made explicit
Mens Animus Intentio Anima. One sealed file of eight megabytes, offline, with no network capability in the code, returning a hash-bound decision and a receipt. Nothing consumes it yet.
inference — the model, with its output checked
Sermo Arbiter Inferentiae Determinata. Deterministic checks on what a model says, with no model judging a model, and the answer held to the evidence the customer supplied. In daily use on our own work.
a governed runtime inside the software you ship
Mathematically Governed Runtime. Released at version 0.2.0, signed, and registered in UCP's pack registry. What gets built is the customer's rule: proved by the engine, sealed into the runtime, embedded at the seam they declare, and changeable later without shipping.
how a changed rule reaches every runtime
Operations Center. Enrolment, heartbeat, rollout, rollback, kill-switch, key rotation and revocation all work end to end. This is the mechanism a rule change travels on.
inside the model
Mathematically Governed Transformer. Eleven kernel-checked theorems, with no unproved steps, and a working edge runtime with zero measured drift, including a bypass we found in our own governor, proved the fix for, and published.
NME · the memory underneath
Resonant Field Storage · Nota Memoria Engine. Exact, semantic and structural memory in one field, with zero measured crosstalk and ambiguity held rather than destroyed. The service around it is next.
orchestration — the plan, and who does what
Coordinatio Auctus Imperium Ordo. Planning runtime sealed, executor ahead of us, and structurally incapable of executing, proved three independent ways.
the personal layer a person actually talks to
Tutelarius Auxilium Intellectus. The assistant a person actually talks to. Real work, and the earliest stage of anything here.
73 Lean files, 627 theorems
Unified Calculus. 627 kernel-checked theorems across 73 Lean files, with no unproved steps. The registry holds 72 published assets, each with a passing Lean 4 validation receipt.
27 stable catalog records, 57 workspaces
Marketplace packages. Seed funding expands that proven lifecycle across the catalog and into customer deployments. No package is yet an external purchase or a customer installation.
mathematical kernel service
Voluntas Engine. Reinforcement learning for policy improvement is specified and verified in notebooks for convergence, exploration, and stability, and is not yet in the runtime code.
a separate product for AI coding agents
Mathematical Governance Engine. Runs as a sidecar service. Approved decisions carry a keyed-hash receipt; the receipts are not public-key signatures, are not chained, and none is issued for a denial.
The Codex case
A bounded task with every control documented ran for seven days and changed 147 files.
In late August 2026 we asked OpenAI's Codex, an AI coding agent, to complete one bounded piece of work: a shared GitHub automation capability. Before it started, the task had an approved objective and plan, acceptance criteria, explicit exclusions, retry budgets, durable checkpoints, independent review, and defined human approval points.
Codex had access to all of it. None of it was enforced at the moment each decision was made. A reviewer's suggestion outside the criteria became a new requirement. The plan was amended thirteen times. Work already accepted was reopened after the agent lost its context. Each change required another review and another round of repair. The software worked at the end; the path to it consumed far more time and usage than the outcome justified.
Cause. The same probabilistic system was responsible both for interpreting the rules and for deciding whether to follow them. Written governance is advice to a model and has no force at the point where the model decides what to do next.
How the fabric prevents it
The Universal Control Plane sits in front of every covered action and checks it against the written rules before the action runs. Applied to this task, five decisions in that incident would have been made differently, and each would have left a record.
A reviewer finding outside the criteria
Recorded as a deferred item rather than adopted as a new requirement. The scope remains as approved.
A change to the plan
Treated as a separate governed action. Codex would have to present the added scope and expected cost and obtain an operator's approval before the contract changed.
A retry with the same failure
The same failure signature with no materially new input is duplicate work and is stopped.
Loss of context mid-task
Recovery starts from the durable checkpoint. Accepted work remains accepted, and the agent returns to the single active action.
Usage beyond the limit
Every covered model and tool call is attributed to the task and checked against its token, time, tool, and retry limits. At the ceiling, work stops or escalates. The agent cannot raise its own budget.
Every decision
Allowed, denied, deferred, or escalated, each recorded with the rule it was checked against. The record exists before the invoice does.
The first unauthorized expansion would have been refused at the first decision, and the subsequent loops would not have accumulated.
Why we did not catch it ourselves. The Universal Control Plane governs our own agents daily, including this one. During the period in question our enforcement was offline for an update and the task ran without it. The difference between a week of drift and a refused first step was whether the gate was in the path, not whether the rules existed. We have chosen to present the failure we experienced rather than a staged demonstration.
Where it applies. Coding agents are the visible example. The same five decisions arise wherever an agent can spend, send, commit, or delegate: sales operations, service, finance, research, and software delivery. That is the market, and this is one workflow within it.
Working evidence
Two working applications, one control pattern
SIGMA and ECC are implemented, working applications in use, not concept demonstrations. SIGMA provides AI-assisted research, backtesting, screen composition, and paper trading, with the control plane gating consequential tools and live trading kept outside the agent's reach. ECC, the Employee Command Center, spans CRM, prospecting, proposals, and the seller journey, with human authority over every enterprise write. Prospect Forge is part of ECC's commercial lifecycle. Both reproduced the same operating pattern: a model proposes, deterministic code decides, one function controls the side effect, a receipt records it, and a person holds the final authority. What remains for them is expansion rather than construction: the single evidence chain from construction receipt to decision receipt, connection to the Operations Center, and the production integrations a customer environment requires.
Going further
This page is the public overview. Deeper material is by request.
Everything SMARTHAUS publishes openly is on this page. The next gate is the full investor master, opened with a firm access code. SMARTHAUS issues one code per firm, either in reply to a request or directly to a firm it approaches.
One public investor overview
The financing, the market transition, what is built, what is not yet built, and who is building it. There is no second public briefing to hunt for.
Enter a firm access code
A code belongs to one firm and may be shared inside it. It opens only the investor master, and it never gains further authority; confidential diligence is a separate credential issued after the agreement is signed.
Request access for the detail
No code yet? Tell SMARTHAUS which firm you are with. Approved firms receive one access code for the firm, not a personal link.
As the conversation deepens
Three gates. The overview, the master, then confidential diligence.
Each gate is a deliberate step rather than a form to fill in. References to specialist material point to packages behind the agreement, not to public pages you need to hunt for.
Public overview
This page is the whole public investor story: the financing, the transition, what is built, and what is not.
The investor master
A firm access code opens the full investor master. One code belongs to the firm and may be shared inside it, so colleagues read the same briefing without each asking for their own way in.
Confidential diligence
A firm requests diligence, SMARTHAUS approves it, and one authorised representative signs the agreement for the firm. Only a completed signature opens the thirteen diligence packages, under a separate credential.
Verify the system
You do not have to take our word for any of this.
Under NDA, we will provide full diligence access to every repository behind these claims—including the source code, working builds, tests, receipts, and construction artifacts—so you can verify the system for yourself.