InferenceOffice
Your Intelligence, Our Inference.
AI-native inference applications. You talk; the finished work product is revealed — not another app to learn. Here's Blackboard, the first one, doing exactly that.
A first working glimpse — an early MVP, not our latest build. You say a little; Blackboard already knows you, spins up its own agents to run the lookups, and writes the finished letter — masthead, body, and signature. Or open the full-screen reel ↗
Making the 80's way obsolete
How Blackboard works
Say it plainly
Rough out what you need on the Easel, the way you'd say it to a person. No menus, no fields to hunt for.
The board pulls threads
It recognizes the task, fills what it can, and runs its own lookups — asking only for the few things it genuinely can't infer.
The work assembles
The finished piece composes itself on the Sheet, one block at a time — ready to send, not another draft to wrangle.
Architecture & vision
Blackboard isn't a chat box with a nice coat of paint. It's the first face of an inference-native system built on four load-bearing ideas.
Write the reasoning once. Wear three faces.
The heart of InferenceOffice is a portable Rust engine — the Dialogue Manager, the memory, and the render substrate — compiled once and run in whichever trusted shell the moment demands.
The offline capsule on your laptop, the hosted app at inferenceoffice.com, and (soon) the browser edge all run the identical core. Sovereignty becomes a deployment target, not a rewrite.
The blackboard is literal.
You talk on the Easel. Each request spins off specialist threads — clarifiers, lookups, agents — that work quietly and post back when they resolve.
What they resolve onto is the Canvas: an ordered set of blocks over one format-free substrate. The finished piece assembles there, one block at a time, and renders to whatever target you need.
Sovereignty is a dial, not a promise.
Per unit of work, you choose where intelligence runs: sovereign — local, nothing leaves the machine — or frontier, routed to a frontier model, and only ever with you shown that data will leave.
In the offline capsule this isn't a setting. A no-network content policy makes a sovereign call physically unable to reach the wire. A hard boundary in code, not a preference.
Sense, don't declare. Render, don't assemble.
You never pick "which app." Blackboard senses whether it's looking at numbers, prose, or a request for action, and fills an explicit, versioned Intent Model as it goes — resolving the load-bearing questions before it builds, never on a guess.
Content stays format-free until the very end, when it is rendered — not assembled — into the finished work. The difference between a consultant and a chatbot.
These are photorealistic interpretations of the system's own architecture diagrams.
The Apps
From talk to work product. Rough out a request and watch the board sense the task, run the lookups, and compose the finished letter — one block at a time.
Open Blackboard →One self-contained .html file — download it and it runs on a laptop with the
network switched off. A signed native macOS capsule is in the wings.
Still in stealth
InferenceOffice is a stealth-mode startup. We're building in the open only as far as showing the work — you can watch the apps and run them today. The company, the roadmap, and the pricing stay under wraps a while longer.
Our model follows nosource.ai: the software is free and inspectable — what you pay for is the service. Free software, fair service.
The wider work
InferenceOffice doesn't stand alone — it grows out of a movement, a foundation, and a builder.
