Skip to content Skip to sidebar Skip to footer

Maven – Production-Ready Systems with LLMs and Agents An Intensive for Engineers

Maven – Production-Ready Systems with LLMs and Agents: An Intensive for Engineers

Released 8/2026
By Ehsan Gazar – Staff Engineer | AI & System Design
MP4 | Video: h264, 1920×1080 | Audio: AAC, 44.1 KHz, 2 Ch
Genre: eLearning | Language: English | Duration: 10 Lessons ( 5h 58m ) | Size: 1.6 GB

Build LLM and agent systems that survive real traffic, cost, and failure.

You can wire up an LLM and demo an agent that wows the room. Then it meets production, and everything you weren’t taught shows up at once: costs spiral, latency balloons, the model does something confidently wrong in front of a user, and you have no evals to catch it and no traces to debug it. The demo was the easy part.

If you’re the engineer now expected to ship AI features, that gap is yours to own, and the field moves faster than anyone can teach it. So you improvise, lean on framework tutorials that stop at the happy path, and quietly hope it holds.

This intensive teaches the part the tutorials skip: the architecture decisions that make LLM and agent systems survive real traffic, real cost ceilings, and real failure. Where to draw the boundary between code and model. How to bound cost and latency. How to design for non-determinism, evals, observability, and human oversight.

You leave with production-grade artifacts you can use at work on Monday: an agent architecture doc, a cost and latency budget, an eval harness plan, and a failure-mode runbook. Not another demo. A system that holds.

What you’ll learn
Master the decisions that take AI agents from demo to production, and become the engineer your team trusts with anything LLM.

Draw the right boundary between code and model

Decide what to hand the LLM and what to keep in deterministic code, the highest-leverage choice in any agent system

Spot the tasks where a model adds risk without adding value, and replace them with plain logic.

Design prompts and tool interfaces as narrow contracts, so the model’s job stays small and testable.

Bound cost and latency under real traffic

Set a per-request cost and latency budget, then design the system to live within it

Apply caching, batching, and model routing to cut spend without losing quality

Right-size the model per task instead of defaulting to the biggest one everywhere

Design for non-determinism and failure

Build retries, timeouts, and fallbacks so a slow or failing model never stalls the system

dd graceful degradation paths for when the model is wrong, unsure, or unavailable

Contain non-determinism with validation and guardrails before output reaches a user

Choose the right agent architecture

Know when to use tool calls, planning loops, memory, or multiple coordinated agents.

Recognize when a single well-scoped agent beats a complex multi-agent design

Map each pattern to its failure modes so you choose with eyes open, not by hype

Catch quality regressions with evals

Build an eval harness that scores changes before they ship, not after users complain

Combine offline test sets with online signals to catch drift and silent regressions

Turn a vague “it feels worse” into measurable quality gates in your pipeline

Operate agent systems with confidence

Trace every LLM call so you can debug what the system did, not what you assumed

Watch cost, latency, and quality on dashboards that surface problems early

Place human oversight and prompt versioning where they actually reduce risk

PRECDERAEDEYRTGELLMAFDRFEAGENTGEINT

you must be registered member to see linkes Register Now

Leave a comment