Pattern: agent runtime + MCP tool-seam + human-approved gate
Proof: Postiz publishes through it, live
Map: the scout reuses the seam, upgrades the gate
The pattern what's already proven live
There is one reusable shape underneath every agentic feature on the platform, and it is worth naming before mapping anything new onto it: agent runtime + MCP tool-seam + human-approved action. It is not a diagram we hope to build — it is running in production today, and the job scout is just the next tool set bolted onto the same skeleton.
Live · the runtime
OpenCLAW holds the reasoning
- The agent runtime — Claude Code + skills, running in a container on the VPS, gateway port
18789.
- It plans the loop, decides which tool to call next, and reads results back — the volatile, replaceable part that lives outside the platform wall.
- It reaches the platform through exactly one thing: the MCP seam. No bespoke backend, no direct DB access.
Live · the seam
oll-mcp is the one boundary
- A thin FastMCP adapter, proven end-to-end over both stdio and HTTP.
- Live tools today:
ollam_draft, ollam_clarify, ollam_memory_search — the last one grounded and cited, returning real chunks with zero fabrication.
- Each tool is a thin wrapper over one live HTTP endpoint. One adapter per external system.
Postiz proves the last hop
The interesting part of an agentic loop is never the drafting — it is the final outward action, the step that touches the real world. Postiz demonstrates exactly that hop: a single thin tool, postiz_schedule_post(text, platforms[], when, image_paths[]), wraps Postiz's public REST API (POST /public/v1/posts) and fans a single call out to 30+ channels. And the outward action is gated — publish defaults to human-approved (confirm=true). The agent drafts the post; a human blesses the send. That is the template the scout inherits.
Three invariants that make it a pattern, not a one-off
invariant 1
Behaviour lives in the agent
Reasoning, planning, tool-choice — all in the runtime, never in bespoke per-product backends. A new feature is a new prompt + tool set, not a new service.
invariant 2
Every capability is a thin MCP tool
One HTTP boundary per capability, never throws (returns isError text, not an exception), one adapter per external system. The seam translates; it does not re-implement.
invariant 3
Outward actions sit behind a human gate
Anything irreversible or outward — publish, send, apply — routes back through a human approval. The agent proposes; a person commits.
Why this matters for the scout: the job scout is not a new architecture to invent — it is invariants 1–3 with a different tool set. Everything below assumes this skeleton is fixed and proven, and asks only "which tools, backed by which live service?"
Postiz seam → scout seam same skeleton, different tools
Map the job-application loop — discover → read → ground/score → tailor → verify → act — onto the proven seam. Each leg is a thin oll-mcp tool over one live service. Read the last column: nothing here is a new backend; it is new tools over services that already run and are health-green.
| Loop leg | Postiz analog | New scout tool on oll-mcp | Backs onto (live service) |
|---|
| discover | — (Postiz: n/a) | scout_search_jobs(query, locations[]) | Web-search adapter — real CH coverage (jobs.ch / LinkedIn / indeed.ch). Not arbeitnow, a German board with ~0 Swiss jobs. |
| read | — (n/a) | scout_fetch_posting(url) | Web-fetch adapter → clean posting text. |
| ground / score | Postiz: ollam_memory_search | scout_score_vs_cv(posting, cv_ref) | oll-memory (Sam's real CV corpus) + the oll-model gateway → fit + gaps. |
| tailor | Postiz: ollam_draft | reuse ollam_draft + dossier verbs | oll-write → tailored CV + cover letter. |
| VERIFY (the killer feature) | Postiz analog: the confirm=true gate | scout_consistency_check(dossier) | Deterministic checks + oll-model → PASS/FAIL + flags. |
| act | Postiz: postiz_schedule_post, human-approved | NO auto-submit tool exists | The human reviews & sends → Sam. |
The upgrade: the scout replaces Postiz's publish-gate with a richer human-approved boundary — a pre-flight scout_consistency_check. Same architectural slot (the last human-blessed step), upgraded from a simple confirm into a structured quality gate. The agent can't reach the world without passing through it, and passing it produces evidence the dossier is coherent.
What the consistency check actually does
It is cross-document validation run before a dossier is marked "ready": company name, role title, dates, and Sam's own name must match across the cover letter, the CV, and the portal fields. That is the exact class of error that would have caught the real mixup — a cover letter addressed to Zühlke, with an ERNI subject line, and Adnovum in the body. A copy-paste dossier that no human would notice until it was already sent.
On top of the identity match sits a calibration lens: it flags claims that quietly got stronger during editing — the drift from "einer der aktivsten" to a bare "aktivste". Not a grammar pass; a truthfulness pass, so the agent's polish never outruns the facts.
The guardrail, stated hard — assistierend statt autonom: because no auto-submit tool is registered on oll-mcp, the agent physically cannot spray applications, even by mistake. There is no code path from the loop to a portal's submit button. The last hop is a human pressing send — by construction, not by policy. That is what makes this honest to build and safe to run against real employers.
The call sequence one job · one agentic loop
A C4-dynamic call sequence for a single job. Each hop is labelled endpoint · protocol · auth. Every tool call is OpenCLAW → oll-mcp over MCP/JSON-RPC, carrying the Core JWT — one identity, one seam. The final hop is the only one no tool performs.
trigger (cron / Sam) → OpenCLAW
local trigger · —
The runtime wakes and starts the loop for one target role.
OpenCLAW → oll-mcp scout_search_jobs → web search
scout_search_jobs · MCP/JSON-RPC · Core-JWT
returns → real Zürich postings (jobs.ch / LinkedIn / indeed.ch)
OpenCLAW → oll-mcp scout_fetch_posting(url) → web fetch
scout_fetch_posting · MCP · Core-JWT
returns → clean posting text
OpenCLAW → oll-mcp scout_score_vs_cv → oll-memory query (CV corpus) + oll-model score
scout_score_vs_cv · MCP · Core-JWT
returns → fit + gaps
OpenCLAW → oll-mcp ollam_draft (dossier) → oll-write
ollam_draft · MCP · Core-JWT
returns → tailored CV + cover letter
OpenCLAW → oll-mcp scout_consistency_check → deterministic + oll-model
scout_consistency_check · MCP · Core-JWT
returns → PASS / FAIL + flags (name / role / dates / calibration)
OpenCLAW → Sam (review surface)
human-approved · no tool does this
the human presses send — there is no registered tool that can
Blue = agent/tool hops over the MCP seam, all Core-JWT-authed. Green = the human-approved boundary. Steps 2–6 pass through one seam; step 7 has no tool at all — the loop dead-ends at a human on purpose.
OpenCLAW
agent runtime · VPS gateway :18789 LIVE
Holds the reasoning. Runs the discover→verify loop. Replaceable without touching anything below.
MCP · JSON-RPC · Bearer <Core JWT>↓
the one reusable seam
oll-mcp
thin FastMCP adapter · stdio + HTTP LIVE
Registers tools, translates each to one HTTP call, never throws. Scout tools slot in beside the live ollam_* tools.
HTTPS · Bearer <Core JWT>↓
frozen
oll-memory
memory.oll.am LIVE
CV corpus · grounded, cited retrieval
frozen
oll-model
model.oll.am LIVE
provider-agnostic scoring + verify
frozen
oll-write
write.oll.am LIVE
tailored CV + cover letter
review surface · human-approved↓
Sam presses send
no tool performs this hop
The loop dead-ends at a human — assistierend statt autonom.
Dashed = external, replaceable runtime. Bold outline = frozen live service. Green = the human gate. The scout tools are the only new component, and they are thin adapters over the four live services above.
Build delta + why this is the right call reuse vs new
The honest accounting: almost the entire loop is reuse of live, proven infrastructure. The new build is four thin tools and one adapter — the whole thing.
Reuse · all live & proven
Already running
- OpenCLAW runtime — live, VPS gateway
18789.
- oll-mcp seam — live, both stdio + HTTP transports.
- oll-memory — live at
memory.oll.am (CV corpus, cited retrieval).
- oll-model — live at
model.oll.am (scoring + verify).
- oll-write — live at
write.oll.am (tailored CV + cover letter).
- Scout #93's scoring / dedup / digest — optional plumbing to fold in.
New · small
The whole build
scout_search_jobs — thin oll-mcp tool + web-search adapter.scout_fetch_posting — thin oll-mcp tool over web fetch.scout_score_vs_cv — thin tool over oll-memory + oll-model.scout_consistency_check — deterministic + oll-model verify.- One web-search adapter with real CH coverage. That's it.
Why this is agentic, not a toolbox: careerset ships six self-serve tools a user drives by hand; this is one agent doing the whole loop — discover, read, ground, tailor, verify — and handing a human a finished, checked dossier. It reuses a live proven seam instead of a bespoke scout backend. And it is the AIOps portfolio artifact: an inspectable agent workflow with structured logging, a cost preview, Core-JWT auth, and human-in-the-loop with an audit trail — the exact shape of work Sam wants to be seen doing.
Honesty note — deliberate, not drift: this is Sam dogfooding plus a portfolio demo. It does not produce the first stranger franc — that is still the foto on-ramp. Building the scout is a considered choice (it reuses the whole live constellation and doubles as the AIOps showpiece), not the ship-vs-build pattern reasserting itself. The revenue frontier stays on the foto path; this rides alongside it, cheap, on infrastructure that already earns its keep.
Agent runtime + MCP tool-seam + human-approved action. Postiz proved it. The scout reuses it and upgrades the gate. There is nothing new to invent — only four thin tools to register.
— one pattern, two products
Single next action: stand up the four oll-mcp scout tools (search_jobs, fetch_posting, score_vs_cv, consistency_check) + the web-search adapter on the existing seam. First real task candidate: generate the Abraxas interview-prep dossier through the loop — a real posting, end to end, with the consistency check on.