Platform 1.0 was stateless tools on two frozen spines: Core knew who you were and took your money; oll-model called any model behind one seam. Competent, but the output was the same output every other wrapper produces — generic prose from a generic model. Anyone can build that. Everyone has.
Platform 2.0 adds the third spine — Memory (oll-memory, live at memory.oll.am). With it, the platform is no longer stateless. It's corpus-grounded: every product can now answer from the customer's own documents, with citations. That single addition moved the unit of value.
This doc refines two siblings rather than repeating them: The Third Spine made the argument for Memory as infrastructure — and that argument is now shipped, no longer an unpromoted branch. The Agent Seam plans the MCP surface so an agent can drive the platform — a plan Sam has now approved. This page ties the live reality together and says what it unlocks. Background: Beyond the Wrapper and The Platform.
oll.am's elegance was always one sentence: frozen infrastructure, disposable products. A product is a thin, throwaway client; the durable value lives in a handful of spines that are built once and never touched again. As of this milestone, all three are deployed and healthy — I verified the health checks: Core, oll-model, and oll-memory all return 200, and CiteBible returns 200 at /carry.
The stack is deliberately boring and correct. LlamaIndex + pgvector + nomic embeddings; hybrid dense + keyword retrieval fused with RRF; generation delegated to the Model spine (Memory never owns a model, just as Core never owns a corpus). The trust boundary is the elegant part: the per-user corpus mem:user:{id} is derived server-side from the Core JWT — the browser never names a corpus, so a user cannot reach another's, architecturally. And honesty is built in, not bolted on: a relevance floor drops noise, and on a miss the system abstains rather than fabricate a citation.
Platform 2.0 isn't a diagram — it's already carrying two live products. Both run on the same Memory spine with zero code duplication; they differ only in which corpus and which front-end. The corpus is a flag, not a fork.
“Scripture for the sentence you are actually carrying.” Type a real human situation — e.g. “my mother is dying and I am angry at God” — and the engine returns real, cited passages (Acts, Luke, Matthew, Mark) with a “Write from this →” CTA.
A public, read-only bible workspace — a corpus behind a server-side allowlist. Free retrieval, no login; honest abstention on a miss.
The 3-pane writing product. LEFT — Your Knowledge (add / search your corpus) · CENTER — the Manuscript editor · RIGHT — Chat / Ask your knowledge base. Drag-to-cite inline [n] citations with a click-to-source trust loop.
A private, per-user corpus — the same engine as CiteBible, pointed at your own documents instead of a public book.
This is the real contribution of the milestone — not a single product but a repeatable shape. Every Platform 2.0 product is the same four things: a corpus + the “carry” UX + Core auth/billing + an optional MCP agent seam. The carry UX is the heart of it — the loop that turns an intent into grounded, honest output:
The elegance: products are now thin + grounded + disposable while the spines stay frozen. A new product is “point at the Memory spine with a new corpus / vertical, add a front-end.” Contrast this with the commodity chatbot — a text box over a raw model. The three differentiators are all in the loop above:
| 2.0 pattern | What it does | Why it beats a commodity chatbot |
|---|---|---|
| Intent-first | the user names the real thing they're carrying, not a prompt | the product meets a person, not a blank box |
| Grounded | answers are drawn from a real corpus, cited to source | trust — you can click through to why it said that |
| Honest abstention | a miss returns nothing, never an invented citation | in a world of confident hallucination, “cited or silent” is the moat |
With three live spines and a reusable pattern, the extension map sharpens. This builds on — doesn't restate — The Third Spine and The Agent Seam. The flagship is the one that uses all three spines at once.
| What it unlocks | Built on | Status |
|---|---|---|
| The career agent oll.in / ollapply | Memory (your experience) + oll-write (cited CV / letter) + the MCP seam (an agent that acts) — the flagship 2.0 product | ★ flagship — after a franc lands |
| Carry-pattern verticals | any corpus → any domain: the same intent → retrieve → cite → write-from loop, a new corpus and front-end away (see the platform) | cheap to add — deferred, not tempting |
| Credits ledger on Core | pay-once credit packs purchasable across every product; Core is the natural owner of per-user state | stub today — per-replica, the one monetization primitive still to promote |
The pattern's payoff is that lighting up the Memory spine lit up every product at once. CiteBible, ollwrite, and the future career agent all get grounded, cited output for free — because the capability lives in a spine, not in each product.
The 2.0 shift lands squarely on oll.am's positioning. The pitch was always “any AI model, without a subscription — pay once.” Add a personal corpus and it gets sharper: “your knowledge, your corpus — pay once, it's yours.” A corpus is exactly the kind of durable, owned asset the pay-once story promises — and a switching cost that stateless tools never had.
| Move | Why it fits Platform 2.0 |
|---|---|
| CiteBible = first chargeable 2.0 product | live now, one Core env flip (PRODUCT_VERIFY_BASE_CITEBIBLE) from Pro checkout. Retrieve free forever; generate FROM the verses is Pro. Paywall on create, not search. |
| A durable credits ledger on Core | makes pay-once credit packs work across every product — the natural home is Core, which already owns per-user identity and billing. Today it's a per-replica stub; promoting it to a durable row is the one monetization primitive still outstanding. |
Here is the part that matters most. Platform 2.0 the platform is already built. Three spines are live, two products run on them, and the pattern is proven. The temptation now is to build the career agent, or a second vertical, or the credits ledger. That is the wrong move — and it's the exact pattern the house guardrail names.
Only after a franc lands does the career agent become the right next build — and by then Memory, MCP, and write are all live, so it's cheap. The sequencing keeps both truths: keep the platform frozen and elegant, but let the next hour go to the first dollar, not the next diagram.
A sweeping platform vision is the exact thing that has historically stalled this project before revenue — infrastructure-before-income dressed up as ambition. So this section treats the Postiz playbook as a lens on what's already half-built, ordered by proximity to the first franc — not as a build queue. The honest read: most of these patterns are already partially real, and the two that matter compound only after users arrive.
| Postiz pattern | oll.am today | Franc-proximity | Effort | Verdict / when |
|---|---|---|---|---|
| 1 · Open-source → hosted-cloud funnel | The ollwrite clarity engine already exists (its own Next.js repo, a thin client of write.oll.am) — not open-sourced yet; roadmap Month-3 “the Ollama for writing” (MIT, self-host free / hosted Pro). |
HIGH — stars = discovery, Sam's documented bottleneck; the open-source is the marketing. | MED | COMMIT #2 (post-franc) — the discovery lever. |
| 2 · API / MCP — “the API is the product” | write.oll.am already exposes clarify / spec / draft / rewrite / expand over HTTP; the Model spine is the frozen any-model gateway; a thin MCP wrapper is already planned — see The Agent Seam. |
MED — unlocks the career agent + “ollwrite as a service.” | LOW | COMMIT #1 (post-franc) — ~80% built, cheapest high-leverage step. |
| 3 · Agent module — background tasks on triggers | The Memory sidecar already does proactive retrieval-as-you-type; CiteBible's step-back “what do you actually need” rewrite is agentic; the landing already promises an Agent module. | MED — product differentiation. | MED | LATER — partially real; productize after the API seam + a franc. |
| 4 · Marketplace / exchange — prompt packs (“Academic tone” $5, “Swiss CV” $9) | Not built; roadmap Phase 3. | LOW — needs a user base first; pays only at scale. | HIGH | DEFER (Phase 3) — do not build before users. |
| 5 · Webhook → automation pipeline — “everything triggers everything” | Core has the Stripe webhook (sole writer of plan, idempotent); no general event bus; the “dark factory” CI/CD is the build-side pipeline. |
LOW — internal efficiency. | MED | LATER — internal glue, not revenue. |
| 6 · n8n / Postiz integration — glue | Not deployed; both are on the roadmap and both self-host on the existing Coolify VPS at ~€0. | LOW–MED — Postiz itself is franc-adjacent: it automates distribution, the bottleneck. | MED | Deploy Postiz soon (distribution automation); n8n glue later. |
| 7 · Platform > Product — the meta-lesson | The three frozen spines — Identity · Model · Memory — already are this; Platform 2.0 is the reframe. | — | — | ALREADY TRUE — the frame, not a task. |
The far horizon is real and worth naming: the three spines + the products + (later) Postiz and n8n, all running together on the ~€5/mo Coolify VPS, are an operating system for a one-person company — identity, billing, memory, generation, distribution, and automation as one owned stack. The honest part is the completion bar: that OS is already ~60% assembled. The missing 40% is users and the two commits above — not more architecture. And the through-line stays true to the pitch: your knowledge, your corpus, “Ollways private” — pay once, it's yours.