Platform 3.0

The always-warm job corpus the beating heart of 3.0

Every pillar below serves one concrete mechanism: a continuously-scouted, RAG-indexed corpus of real, live job postings that is always fresh and always warm. Because a cron keeps it pre-loaded, a visitor lands and immediately sees real, relevant, matched jobs they can apply to in a few clicks — Ollie prepares the dossier, you approve and send. That kills the cold-start "empty app" problem that murders job tools: the product is alive on arrival.

1. Continuous scout (cron). OpenCLAW runs on a schedule (hourly / daily) and pulls fresh postings from legal job APIs — Adzuna, Arbeitnow, Jooble — never scraping ToS-restricted boards (LinkedIn, jobs.ch). Cache minimally, attribute the source, link out to it, delete stale listings.
2. RAG the jobs. Each scouted posting is embedded (Model · nomic-embed-text) and stored in the Memory spine (pgvector) as a live JOB corpus that's always fresh and warm — not fetched on demand.
3. Two corpora, RAG on both sides. Memory now holds (1) the user's experience corpus (CV / history — grounding for applications) and (2) the live jobs corpus (recall + suggestion). Matching = retrieve postings semantically relevant to the person's own corpus — fast recall + personalized suggestion that sharpens as they interact.
4. Instant value — the killer UX. Because cron pre-warms the corpus, the visitor doesn't wait: they arrive to real matched jobs. Alive on arrival kills cold-start. It's also a conversion mechanic — which is why, though the full machine is 3.0, land → see real matched jobs is worth pulling forward.
5. Signals feed back. Interactions re-score ranking and suggestion — this is where the corpus becomes Measure's substrate and the loop starts to learn.

The pieces this rides on already exist and compose: the Memory spine (pgvector + nomic embeddings), the agent seam (OpenCLAW cron + scout), and Model (embeddings + generation). The genuinely-new bits are small and additive — see the reuse-vs-build ledger.

The 1.0 → 2.0 → 3.0 arc where 3.0 sits

oll.am's story is three moves. Each earned the next. 3.0 is the one that hasn't started.

The technique is not new — it's exactly what the indie-founder growth stack does to a product. 3.0 points that same machine at a person's career: run your job search like a founder runs growth. Siblings: Platform 2.0 (the spines & seam that make this possible) · The Agent Seam · The Constellation (what's already on the box).

The four pillars the growth machine, decomposed

The indie-founder growth stack is four moves — Measure what makes money, Prove it un-fakeably, Act on it autonomously, Distribute the result. Each has a reference product. For each, here's what it is, its signature move, and its job-search equivalent.

Your data, as a product Measure + Prove, made a surface you touch

The pillars above run the machine for you. But the same data the machine already holds — the RAG'd live job corpus, your application funnel, and your interaction signals, all sitting in the Memory spine — is also something you should be able to touch directly. Not just a backend Ollie reads: a product surface. This is Measure and Prove turned user-facing — three faces of one data layer, sitting alongside the agent, on the same rows.

Chat with your data

DataFast's "AI analyst" pattern, pointed at your own job search: ask natural-language questions over your data and get answers — "which of my applications got a reply?" · "what's my interview rate?" · "what roles pay most for my skills?" · "which cover-letter style converts?". Under the hood it's NL → query / retrieve → answer: oll-model turns the question into a query over the Memory-spine data, retrieves the relevant funnel rows and corpus matches, and answers in plain language. No dashboard-spelunking — you just ask.

Insights, like DataFast

Your job-search analytics and attribution, surfaced the way DataFast surfaces revenue: response rate · ghost rate · interview-conversion % · time-to-reply, plus which channel / CV variant / role-type converts and your market position. This is the Measure pillar made a visible surface — the career funnel measured and shown, not left as backend jargon feeding the agent. Rendered the same state.py → HTML way the Control Room already renders live state.

Verified — TrustMRR-vibes for your career

Your track record is un-fakeable because it rides on Ollie's own logged actions — applications actually sent, replies actually received — aggregated and third-party-verifiable, exactly like TrustMRR verifies revenue on real Stripe events rather than self-report. It's a trust primitive for a job-seeker: not a CV claim you type, but a record the machine wrote. This is the Prove pillar made user-facing — the same "verification on real events, not self-report" idea, now a credential you can show.

Why this is reuse, not a new build. The Memory spine is the DB/RAG (pgvector); oll-model does the NL→query, the chat, and the insight generation; and the data — job corpus + funnel + signals — is already being captured by the machine. So DB-as-a-service is the same spines exposed as a user surface: an additive UI plus a thin query/insight layer, no new backend service. See the extended reuse-vs-build ledger below.

The 3.0 edge — integrate even better why owning them beats renting them

The four reference products are four SaaS silos: four logins, four datasets, no shared brain. oll.am owns self-hosted, agentic versions of all four on ONE box, behind one identity (Core) + Memory + OpenCLAW + oll-mcp. That single fact lets the pillars compose into a closed loop the silos structurally cannot.

Concretely, the five things owning-not-renting unlocks:

1. Shared identity + one dataset. The whole funnel lives in Memory — one corpus, not four exports that drift out of sync.
2. One agent, closed measure→act→measure. One OpenCLAW agent reads its own analytics, decides, acts, distributes, logs the verified outcome, and re-scores next cycle — with no human relinking.
3. One dashboard. Render the whole loop from state.json the same way the Control Room already renders live state.
4. Verification is automatic. It rides on the agent's own logged actions — un-fakeable because the machine, not a human, wrote the record.
5. No billing/rate-limit drag. Self-hosted OSS on the box already paid for; it runs on cron continuously instead of metering every event.

The closed growth loop measure → act → distribute → prove → measure

The four pillars aren't a list — they're a cycle. Each turn feeds the next, and the last feeds back into the first. This is what the silos can't do: close the loop without a human carrying data between logins.

Dogfood = demo run the machine on oll.am itself first

The safest, most honest way to prove 3.0 works is to point it at oll.am itself before pointing it at anyone's career:

OpenCLAW cron-drafts the build-in-public updates → Postiz schedules them → the measure layer tracks post → signup → first-dollar (revenue-attributed) → TrustMRR's already-verified badge proves it worked. Once the identical machine grows oll.am's own numbers, it IS the product for a user's job search — swap "revenue funnel" for "career funnel" and nothing else changes.

Reuse-vs-build ledger what's already here vs what's genuinely new

3.0 sounds ambitious; it's mostly wiring things oll.am already owns. The honest accounting:

Highest-leverage first franc-gated — the single first move

When 3.0 does begin — after the first franc — the highest-leverage first build isn't the career product. It's wiring the closed Measure → Act → Distribute loop on oll.am's own build-in-public. That single loop is both the oll.in MVP skeleton and its own best marketing.

Research sources — datafa.st · trustmrr.com · github.com/openclaw/openclaw · github.com/gitroomhq/postiz-app