DreamerOS

The work you do not see.

Every other AI hands you the model output and calls it done. DreamerOS adds five kinds of work between the model and you: it answers the way you think (calibration), it remembers your setup so you do not pay for it on every message (cached intent), it catches mistakes before you see them (caught counterfactuals), it goes with you to other AI apps (portability), and it says plainly what each plan gets (tier clarity). Read what is live today and what is coming, honestly.

What you feel that the model alone never gave you.

Each card names the difference, what it does for you, and what is live today versus what is shipping next. No hedging. If something here does not say "live today", it is not sold as live anywhere on this site. That is the rule.

1. Calibration to you

It answers the way you think.

Your cognitive fingerprint (a profile of how you like to think and be answered), 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 (matching the depth of each answer to you) ships on every chat turn. Intent and emotion classification are wired through the gateway and visible on the receipt strip (the short record under each answer). Depth proportionality is audited after the model speaks.

2. Cached intent economics

You pay for your setup once, not on every message.

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 more of your intent the system carries, 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

Mistakes get caught before you see the answer.

The intent-fidelity checks and the trust-wall (the checks on sources and links) flag made-up facts (hallucinations), parts of your question that were quietly dropped (silent drops), and unverified citations before the answer reaches you. Earned Answers (the row of chips under each answer) surfaces what the response survived and what you can still demand. What could have gone wrong (the counterfactuals) gets named, not buried.

Live today. Fidelity checks before and after every answer, second-opinion verification, and the survived-checks chip row are shipping in the app today. An iterative vision critique for images comes next, as it is wired.

4. Portable fingerprint via MCP and desktop

Your setup goes with you to other AI apps.

One MCP URL plugs your DreamerOS setup 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

Each plan says plainly what you get.

One plans page names what each plan gets versus the next, with no hidden gating and no "premium that quietly downgrades you".

Live today. The gateway reads each feature limit from that one table. See what each plan includes. One image method is live today as well: a 3-engine vision critique on images, where your plan includes it. An iterative critique loop comes next, as it is wired.

How we ship: the 7-stage discipline.

In plain words: most software calls a feature "done" when the code gets accepted. That is a restaurant calling your dinner done because the chef read the order. 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 stranger can use the change end to end on the live product, and we keep the receipt. 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 automatic check keeps every pull request's title and description honest: it rejects the wrong punctuation marks on sight, and it refuses any request that cites a change it does not actually make. The story around the code has to stay true to the code itself.

3. Operational secrets stay out of public docs

An automatic content scanner runs on every change to the public canon and 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 it ships. The public canon stays sellable; the operational internals stay private.

4. Deploy guard refuses unsafe infrastructure changes

The deploy step is boxed into its own folder on the server. Past incidents proved that a change reaching outside it, or writing to the wrong 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 AI grader scores the pull request for made-up claims, missing 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. A person 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 (a six-row check, named for our rule number 37) 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. You can ask your 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 difference. 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.

Caching your setup 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.

Live Trust audit log shipping in the app today. Chat turns earn a signed receipt; if signing fails, the answer still arrives without one. See the record.
Live 3-engine vision critique on image generation. Iterative loop coming as wired.
Live MCP gateway and desktop connect for any MCP-compatible client. Open Connect Setup.

We do not publish fabricated counters. The fleet savings figure above, when it shows, is served live by the gateway as a pure aggregate - one sum, two counts, and the same dollar estimator the in-app weekly figure uses, with no user identifiers in the response. If the gateway cannot vouch for a real number, the figure does not render at all. The real per-customer proof lives in your own record in the app: The record, every check signed and kept. What that record is and why it matters is explained on /audit-log. And the record of our checks is public: read it yourself, no account - the Intent Fidelity Log, an append-only feed where every entry hash can be recomputed from the fields shown, so a mirror can prove nothing was quietly removed.

If you paste DreamerOS into another AI, four pillars travel. One does not.

Bring-your-own-LLM (BYOLLM: you paste your DreamerOS setup into another AI app) is real. Your cognitive fingerprint, your direction set, your operator canon (the rules you saved on purpose), 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 Keeping a Person in Charge.

What does NOT travel: Pillar 3, No Silent Drift (catching an answer that quietly drops part of your question or wanders off it). 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 integrity protection 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. Card 4 above is the short version; this is how it works. Your cognitive fingerprint and your cold-start anchors (the short notes DreamerOS saves so a new chat starts informed) 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 signed-in response from the DreamerOS gateway (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. And the claim-check surface is live in the app today: open What you rely on to find the claims you are counting on that you are not watching.

Want the deeper read on what makes this different? Under the hood walks the pipeline. The Intent Fidelity Protocol spec is the contract.

Plain words for the words on this page

Page. A single screen on this site, like the one you are reading. It is not a unit you buy and we never charge for one.

A client-side path in the web app, served over HTTPS; not a billing unit in any plan.

Token. The small pieces a computer chops your words into, about three quarters of a word each. Your plan sets how long one answer can be, counted in tokens. It does not set how many questions you may ask.

Max tokens per response, one value per plan. Each plan card lists its own.

Engine. One AI brand you can talk to. ChatGPT, Claude, Gemini, Grok and Perplexity are the five. Your plan page lists which ones you can use.

Five role names per plan (Build, Review, Synthesis, Signal, Research). Some plans count the engines you connect live, and the limit is checked on every request.

Connector. A link between DreamerOS and a tool you already use, such as Gmail, Notion, Slack, GitHub or Stripe. It lets DreamerOS read from that tool, and in some cases act in it, but only inside rules you set.

39 provider integrations on the gateway, each reached over HTTPS with a scoped, per-provider key.

Receipt. A short record attached to your answers. It names which engine answered, what it cost, which checks passed, and whether sources were checked. You never have to guess what just happened.

One record per answer, written server-side on the gateway: engine, model, plan, cost, and the pass or fail result of the pre-check and post-check.

Memory. The facts about you that DreamerOS keeps and reuses next time, so you stop repeating yourself. Your plan sets how many facts it holds.

Active memory rows per plan, with a smaller fallback for a session with no plan set yet. Each plan card lists its own.

MCP key. A key you paste into another app, such as Claude Desktop or Cursor, so DreamerOS memory and checks work there too. You do not have to change where you already work.

A signed key. Individual tools inside it may carry a plan floor.

Intent fidelity. Checking that the answer answers the question you actually asked, not a nearby one that was easier.

A rule-based check that runs on the gateway, scored on three axes, with no separate model call.

Direction set. The standing written instructions DreamerOS gives every engine before it sees your question, so all five behave the same way.

One canonical system prompt, loaded by the gateway and sent to every engine.

Direction Set Workshop. Every new AI tool makes you explain yourself from scratch: how you decide, how deep you want answers, what you will not put up with. DreamerOS learns that from how you use it. The Workshop turns it, plus your own rules, into text you paste into any of 21 other AI tools, so they start from what DreamerOS knows instead of from zero. It is a paste, not a live link, so over a long chat the other tool can still drift. Inside DreamerOS, every answer is checked.

POST /api/v1/direction-set/assemble reads your cognitive_fingerprint record and returns plain text for the tool you pick; presets save named versions.

Check. A test run on your question before the engine sees it, and on the answer before you see it.

A pre-check before the engine sees your question, and a post-check before you see the answer; both results ride the receipt.

DreamerOS Light is free - try the integrity pipeline Try it now