I'm Peter Sjolin. I design and run LLM systems in production — solo, end to end. The hard part of AI engineering isn't calling a model; it's making it reliable: job queues that survive failures, human approval gates, deterministic outputs, and cost control. That orchestration layer is what I build.
What production LLM engineering actually takes
Most "AI integrations" are a single model call sitting inside a request handler. That works in a demo. It breaks in production, where model calls are slow, rate-limited, and occasionally wrong. Making an LLM dependable is an engineering problem, not a prompt problem. Four things carry the weight:
Durable job queues. LLM work belongs in a queue, not a request. I run it on River backed by Postgres, with retries, error handlers, and a dead-letter path — so a timeout or a rate-limit retries and recovers on its own instead of failing a user.
Human-in-the-loop gates. Autonomous is not the same as unsupervised. My pipelines pause for a person's approval before they publish anything or spend anything, so automation never runs past the point where judgment matters.
Deterministic outputs. I constrain responses to strict JSON schemas that parse straight into typed Go structs. Code depends on the contract, not on the model's mood — a malformed response is a caught error, not a silent corruption.
Cost control through model tiering. Cheap, fast models handle high-volume work; frontier models are reserved for the steps that actually justify them. Quality where it counts, cents everywhere else.
Worked example: MarketVerdict
MarketVerdict analyzes how viable a business idea is. It's a good example precisely because the LLM is one stage in a grounded pipeline, not the whole product. Here's the flow:
What makes it reliable:
Grounded, not guessed. Location and competitor data come from live map providers with dual-provider fallbacks (LocationIQ→Nominatim, Geoapify→Overpass), so a provider outage degrades gracefully instead of failing.
Deterministic scoring before the LLM. Unit economics, break-even, and competitor density are computed in code first. The model writes about the score — it doesn't invent it.
Queued generation. Paid users get a deeper, tailored plan as a separate River job (TailoredWorker) that retries and recovers on its own.
Model tiering. A cheap model handles the standard analysis; the full model is spent only on the paid tailored plan.
Localized end to end. Two-stage translation — an English draft fans out into nine more languages — Playwright-verified across all ten subdomains.
Autonomous content pipeline
MarketVerdict's blog runs itself. A scheduled job discovers source material, an LLM drafts a post, and the draft goes out for approval by email — approve, edit, or reject in one click — before anything publishes. It's a full autonomous loop with a human gate at exactly one point: the decision to publish. Same patterns as everything else here — queued, retried, gated.
Breadth
Multilingual video pipeline. Autonomous localized demo videos: Playwright captures the screen flow, an LLM translates the script, ElevenLabs generates the voiceover, and ffmpeg assembles the final cut — in ten languages, unattended. It's what localizes MarketVerdict's demos.
OSINT tooling.TraceCheck (live on this site) scores a person or entity's public footprint 0–100 from live search signals, behind a queue, rate limiting, and payments.
MCP orchestration. I wire operational tooling into my LLM workflows over MCP — for example Honeybadger for error monitoring — so the systems I build are observable and debuggable, not black boxes.