The work you do not see.
Every other AI hands you the model output and calls it done. DreamerOS adds the work that sits between the model and you - calibration, governance, caught counterfactuals, portability, tier clarity. Five customer-felt moats. Read what is live today and what is coming, honestly.
What you feel that the model alone never gave you.
Each card names the moat, what it does for you, and what is live today versus what is shipping next. No hedging.
1. Calibration to you
Your cognitive fingerprint, intent, feeling, and the depth you asked for shape every answer. The system reads how you think and matches it. Two people asking the same question get answers calibrated to each of them.
Live today. Mind's Eye calibration ships on every chat turn. Intent and emotion classification are wired through the gateway and visible on the governance ribbon under each answer. Depth proportionality is audited after the model speaks.
2. Cached governance economics
Your standing rules, fingerprint, and direction set get cached at the model boundary so you pay for that overhead once, not on every turn. The deeper your governance, the more you save per message.
Live today. Prompt-prefix caching ships on the gateway against the vendors that expose it. Per-vendor savings differ - see the engine-by-engine table below. Never sold as a flat-rate discount.
3. Caught for you, before you ship
DAIM and the trust-wall flag hallucinations, silent drops, and unverified citations before the answer reaches you. Earned Answers surfaces what the response survived and what you can still demand. Counterfactuals get named, not buried.
Live today. DAIM pre and post checks, second-opinion verification, and the survived-checks chip row are shipping in the app today. Iterative vision critique for image output is coming as wired for Elite.
4. Governance portability via MCP and desktop
One MCP URL plugs your DreamerOS governance into Claude Desktop, Cursor, Perplexity Desktop, and any MCP-compatible client. The fingerprint, memory, and direction sets follow you across vendors. Your standards travel with you, not the other way around.
Live today. The MCP gateway is live and Connect Setup ships an OS-aware guided install. Reach for it from Connect Setup.
5. Tier-value clarity
Light, DreamWeaver, Pro, Elite. Each tier names what you actually get versus the next, with no hidden gating and no "premium that quietly downgrades you". The five-engine constellation, file absorption, image generation, and direction sets all map to specific tiers on a single tier matrix.
Live today. Tier matrix and per-feature gating ship on Pro, Elite, and Light. The 3-engine vision critique is the live Elite image method; the iterative critique loop is the next image moat coming as wired.
If a moat does not say "live today", it is not sold as live anywhere on this site. That is the rule.
The next moat is named before it is sold.
Three patterns the rest of the industry has not named yet. We are shipping them. We name them here so you can see what category we are creating, with the same "live today versus coming as wired" honesty as the five moats above.
1. Modality-Routed Governance
Route each input to the engine that perceives that input best, not to the cheapest API.
The industry pitch is "one API, every model" - route to the cheapest token. That is vendor routing. DreamerOS routes by what each engine is best at perceiving. Claude reads composition, narrative, and emotion. GPT reads optics, light physics, and materials. Gemini reads color, space, and balance. Perplexity grounds facts in citations. Grok pressure-tests creative risk. The unit of competition stops being a token and starts being a calibrated answer.
The first lived instance: before any pixel generates on an Elite image, three engines co-author a single master brief. The synthesizer braids the surviving contributions into one directive that none of the three authored alone. That braided brief becomes the base intent for every quorum candidate.
Live today: Constellation Step 0 ships in the gateway at gateway/app/constellation_brief.py, gated by IMAGE_CONSTELLATION_ENABLED, default on in production as of 2026-06-25 (HC confirmed). Wired and held back: the broader cross-modality routing matrix is the next sprint, not a claim of completeness today. See the philosophy entry.
2. Connector As Turn
Every external system call is a governed turn through the integrity pipeline, not a webhook with a key.
The industry treats connectors as plumbing - paste a token, the data flows, the model reads whatever comes back. DreamerOS treats every connector ingest as a turn. The same pipeline that governs a chat message governs an external read: intent shaping, integrity checks, fidelity contract, signed receipt. A connector is not a side door around governance. It is governance applied to a different input source.
The spine is wired. The /connect surface lists every connected provider. The next bite closes the loop for every read path: signed receipt per ingest, drift surfacing per provider, end-to-end coverage of the read-side governance. Until that ships for a given connector, this page does not claim it as live.
Live today: the connector inventory and the gateway-side write-path through the chat pipeline. Shipping next: end-to-end read-side governance per provider. The honest framing matters more than the marketing copy. See the philosophy entry.
3. Sense-Agnostic Integrity Protocol
The Five Pillars bind every input modality, not just text.
Industry guardrails stop at text. Role-based access, redaction, and content filters are all calibrated to characters. Voice, image, file, and connector ingests pass through with a different rulebook, often none. DreamerOS extends the Intent Fidelity Protocol across every sense. The same Five Pillars - Anchor Before Analysis, Verified Not Trusted, No Silent Drift, Compound Over Linear, The Human Conductor - bind a transcribed voice note, an uploaded image, an absorbed file, and a connector read.
Coverage today, honest per modality:
| Modality | Status | What is wired |
|---|---|---|
| Text | Live | Restructure and integrity checks ship on every chat turn. Visible on the governance ribbon under each answer. |
| Voice | Live | Transcribed voice runs the same restructure path via the voice input tag, then the same checks as text. Audit log shows the same governance fields. |
| Image | Live | The image prompt text runs through restructure on both generate and edit paths. Elite image generation adds the 3-engine vision critique. |
| File | Shipping next | File ingestion currently bypasses restructure. Closing this is the active bite; not claimed as live until it is. |
| Connector | Wired, partial | Write-side governance ships today on the chat pipeline. Read-side per-provider receipts are the next sprint - see Connector As Turn above. |
The contract: Five Pillars bind every modality. The receipt: the coverage row above. We update this table when a row moves, not when marketing pressure asks for it. See the philosophy entry.
These three are not sold as finished products. They are the category we are creating. Each row above is a checkable claim; if any drifts, the table moves first and the marketing follows.
How we ship: the 7-stage discipline.
Every "live today" line on this page is backed by a pipeline that does not say done when the code merges. It says done when a customer can use the change end to end. Here are the seven stages, in plain language, with the gate that protects each one.
1. Code wired
Every change goes through pull request review. The PHP syntax sweep on every page runs on every pull request, so a typo cannot ship a 500 to a customer. Imports resolve, lint is clean, the change actually parses.
2. PR-body and title are honest
An em dash audit fails any pull request title or body that contains an em or en dash, because spaced hyphens are the canon. A metadata cleanliness check refuses pull requests whose body cites file lines that no longer exist in the diff. The narrative around the code has to stay true to the code itself.
3. Operational secrets stay out of public docs
A Crown Jewels scanner runs on every change to the canon and the public docs. If a contributor accidentally pastes a token path, a vendor playbook, or an internal attack surface into a public file, the scanner catches it before merge. The public canon stays sellable; the operational internals stay private.
4. Deploy guard refuses unsafe infrastructure changes
The FTP deploy is jailed into the document root. Past incidents proved that climbing out of the chroot or writing to a nested directory takes the site down. The deploy guard refuses any change to the deploy config that would do either. The infrastructure cannot regress through a quiet edit.
5. LLM grader reads the change (advisory, not blocking)
An LLM grader scores the pull request for hallucinated claims, missing held-back scope, and citation drift. We read the verdict as advice, not as a gate. A red grader verdict does not block merge by itself, because graders drift faster than the codebase does and we do not want a model upgrade to silently raise our merge bar. The human conductor still owns the merge decision.
6. Deploy lands and the site is live
Push to main triggers the Apache FTP deploy. The cache purge fires after sync. The deploy log carries the merged SHA. Nothing is claimed live until the merged commit is the one serving traffic.
7. Six-row walk: done means customer-usable
The P37 walk is the finish line: code path connects, deploy is live, customer can reach the capability at the intended tier, the capability delivers what the directive promised, no surface oversells it, and failure is observable. If any one row is false, the change is PARTIAL or OPEN, never DONE. Pro and Elite customers can ask their AI for a row-by-row receipt against any DreamerOS capability they depend on; the audit log holds the signed turn that produced the walk.
The deep read: How We Ship walks the six-row P37 contract and names the gates above with the same "advisory versus blocking" honesty we use everywhere else on this page.
Transparency is the moat. The pipeline above runs on every change to this site, the app, and the gateway. When a gate fires, the change waits. That is why the claims on this page do not drift.
Cached governance is real savings, vendor by vendor.
When marketing says "90 percent off", the question is always "off what, against which vendor, under what conditions". Here is the honest breakdown. Every cache claim DreamerOS makes carries the engine qualifier. We never say "90 percent off across all engines" because it is not true on any vendor.
| Engine | Cache discount on the cached prefix | Notes |
|---|---|---|
| Anthropic Claude | Up to 90 percent off the cached prefix on a one-hour warm window | Prefix caching with explicit cache_control. Five-minute and one-hour TTLs. Cache writes cost extra; reads are the discount. |
| OpenAI | 50 percent off cached input tokens | Automatic prompt caching on supported models. Applies to the cached input portion only. Output tokens billed normally. |
| Google Gemini | Up to 90 percent off cached input on explicit context caching, plus per-token storage cost | Explicit caching with a minimum cache size and a separate storage fee while the cache is alive. Implicit caching also available with smaller savings. |
Sources, current as of this page going live: Anthropic prompt caching. OpenAI prompt caching. Gemini context caching. Vendor terms change; if a number on this page drifts from the vendor doc, the vendor doc is right and we will update.
We do not publish fabricated counters. The real per-customer proof lives in your own audit log on /audit-log. When public aggregate proof becomes safe to share without leaking individual usage, it lands here. Not before.
If you paste DreamerOS into another AI, four pillars travel. One does not.
Bring-your-own-LLM is real. Your cognitive fingerprint, your direction set, your operator canon, and your cross-vendor continuity all travel via one paste into any chat surface that accepts a system prompt. That is four of the Five Pillars: Anchor Before Analysis, Verified Not Trusted, Compound Over Linear, and The Human Conductor.
What does NOT travel: Pillar 3, No Silent Drift. That pillar requires the DreamerOS gateway runtime to catch silent drops, intent drift, and hallucinations in real time. A pasted system prompt cannot enforce gateway-side rules. Anyone telling you their pasted prompt enforces full integrity protection on another vendor is overselling.
Translation: BYOLLM gives you DreamerOS-shaped behavior on any tool. Full IFP enforcement still lives on the gateway. We call this out everywhere because it is the honest line.
Same memory. Same fingerprint. Anywhere you log in.
Most AI tools start every session from zero. Switch tabs, switch devices, switch vendors, and the assistant forgets you. DreamerOS treats that as a defect. Your cognitive fingerprint and your cold-start anchors are stored on the gateway, not in any one chat surface, so the same operating context follows you to the app at app.dreameros.app, to the MCP gateway, to the SDK, to the API, and to any unsupported connector that can read a public discovery doc.
The contract any client can read: /.well-known/dreameros-continuity.json. It names the endpoints, response headers, anchor shape, and per-tier anchor counts so a brand-new client can wire continuity in without a private playbook. Customers who have never tuned an AI in their life get the same compounding benefit as a power user, automatically.
Live today. Every authenticated response from the SCS gateway carries the three X-DreamerOS-Continuity response headers on the wire (Discovery, Anchors, User-Tier). The discovery doc at /.well-known/dreameros-continuity.json publishes the contract any client can read, the /user/me endpoint and every chat or chat-stream turn folds the customer's cold-start anchors into the response, and the MCP initialize handshake on both transports (streamable HTTP and legacy SSE) emits the same headers so a foreign MCP client gets the anchor count and tier on its first call. The frontend ContinuitySurface on /connect lights up automatically when the headers arrive. Held back, named not silent: a /trust-audit row that visualizes the anchor handoff per session ships in a follow-up.
Want the deeper read on the moat? Under the hood walks the pipeline. The Intent Fidelity Protocol spec is the contract.