workshop

Event

Durability

Agents run for minutes or hours, call slow tools and sometimes wait for a human. If the process dies halfway, the run is gone and you start over, sometimes repeating actions that already happened. In this workshop we use Temporal to make a long-running agent durable, so it survives failures and resumes where it stopped. What we'll cover: - Why long-running agent runs fail in production: crashes, timeouts, restarts, retries - Checkpointing agent state so a run can resume from another process - Pausing for human approval and resuming later - Making side effects idempotent so a resumed run doesn't do things twice - LangGraph checkpointing as an alternative, and when a plain loop is still enough You'll leave knowing how to make your own agent runs survive failures. Who it's for: people running agents that take real actions or run for a long time. Prerequisites: Python, an LLM API key, a basic agent with tools. Our Temporal workshop is related. The code and recording are shared with members after the session.

Jan 12, 2027

workshop

Event

MCP

MCP lets you write a tool once and use it from many clients: your own agent, Claude Code, Cursor, VS Code. Our previous MCP workshop is more than a year old, and a lot has changed since. In this workshop we build an MCP server and wire it into several clients. What we'll cover: - What MCP is and when it is worth using instead of plain function calling - Build an MCP server that exposes tools to an agent - Connect it to our own agent and to coding assistants - Run the server locally, then deploy it as a remote server - Add authentication to the remote server and what to watch out for when you share it You'll leave with a working MCP server you can extend for your own tools. Who it's for: people building agents or using coding agents who want to give them their own tools. Prerequisites: Python, an LLM API key, a coding assistant you use (Claude Code, Cursor, Codex or similar). The previous workshop, Building AI agents with MCP, PydanticAI and OpenAI, is a good intro. The code and recording are shared with members after the session.

Jan 5, 2027

workshop

Event

Freestyle Workshop

A freestyle workshop: you come with your own topic, problem or question, and we work on it live. We try to turn something useful into working code during the session. Previous freestyle sessions ended up as deploying an agent to AWS Lambda and serving open models with vLLM on RunPod. Since there is no prep, we also hit real problems along the way, and we talk a lot about the process: how to work with coding agents, when to trust them, and when to slow down. Who it's for: AI Shipping Labs members who want to build something together and see how real development work happens. Prerequisites: none. Bring your topic, problem or question. The code, recording and a written tutorial are shared with members after the session.

Jan 4, 2027

workshop

Event

Memory

Every new agent session starts from zero. The agent forgets what the user told it yesterday, and stuffing the whole history into the prompt gets slow and expensive. In this workshop we build our own memory implementation for an agent, without a memory library: what to keep, what to summarize, and what to retrieve. What we'll cover: - Short-term memory: the conversation and how to keep it within the context window - Summarizing and compacting long histories - Long-term memory: storing facts about the user and retrieving them when relevant - When memory helps and when it makes the agent worse - How to check that memory actually improves answers You'll leave with an agent that remembers across sessions and a clear idea of which memory approach fits your project. Who it's for: people building assistants and agents that talk to the same users more than once. Prerequisites: Python, an LLM API key, basic RAG or agent experience. The code and recording are shared with members after the session.

Dec 14, 2026

workshop

Event

Prompt Injection

As soon as an agent reads untrusted input (emails, web pages, GitHub issues, documents) and has tools, someone can tell it what to do. Guardrails for topicality don't protect against that. In this workshop we attack our own agent with prompt injection and then defend it. What we'll cover: - What prompt injection is, direct and indirect, and why tools make it dangerous - Attack our own agent with tools live and break it with injected instructions - Add defenses: input and output checks, least-privilege tools, sandboxing tool execution - What each defense does and doesn't stop - How to test your agent against injection regularly You'll leave knowing how to assess the risk for your own agent and which defenses to add first. Who it's for: people building agents that read external content or take actions. Prerequisites: Python, an LLM API key, a basic agent with tools. Watching Guardrails for AI agents first helps. The code and recording are shared with members after the session.

Dec 8, 2026

workshop

Event

Freestyle Workshop

A freestyle workshop: you come with your own topic, problem or question, and we work on it live. We try to turn something useful into working code during the session. Previous freestyle sessions ended up as deploying an agent to AWS Lambda and serving open models with vLLM on RunPod. Since there is no prep, we also hit real problems along the way, and we talk a lot about the process: how to work with coding agents, when to trust them, and when to slow down. Who it's for: AI Shipping Labs members who want to build something together and see how real development work happens. Prerequisites: none. Bring your topic, problem or question. The code, recording and a written tutorial are shared with members after the session.

Dec 7, 2026

workshop

Event

AI System Design

AI engineering interviews increasingly include a system design round: design a RAG assistant, a support agent, a document pipeline. It's a different skill from writing code, and there is little good practice material for it. In this workshop we cover both sides: how to approach AI system design interview questions, and how real AI systems are architected. We go through questions live and design the systems step by step. What we'll cover: - What an AI system design interview looks like and what interviewers check - A step-by-step way to approach a question: requirements, data, retrieval, model choice, tools, evaluation, monitoring, cost - Design one or two systems end to end on a whiteboard - How the same decisions look in real-world AI system architecture - The trade-offs that come up again and again: latency vs cost, RAG vs fine-tuning, single agent vs multiple agents - Common mistakes You'll leave with a framework you can use for system design interviews and for designing your own projects. Who it's for: people preparing for AI engineering interviews, and engineers who want to design AI systems more deliberately. Prerequisites: basic understanding of LLMs, RAG and agents. The recording is shared with members after the session.

Nov 30, 2026

workshop

Event

Evals in CI

You change a prompt, the tests pass, and the agent quietly gets worse. Most teams run evals by hand, if at all, so regressions slip into main. In this workshop we take an eval set and run it in CI, so a pull request that makes the agent worse doesn't get merged. What we'll cover: - Start from an existing eval set for an agent (we built one in the eval framework workshop) - Make the eval run reproducible and fast enough for CI - Run the eval suite with pytest in GitHub Actions on every pull request - Define thresholds and fail the build when quality drops - Report the results on the pull request so you can see what changed - Keep the cost of running evals on every PR under control You'll leave with a CI setup that gates merges on agent quality, which you can copy into your own project. Who it's for: people who already have an agent or RAG app with some tests or evals and want to stop regressions. Prerequisites: Python, Git and GitHub (we use GitHub Actions), an LLM API key. Watching the eval framework workshop first helps. The code and recording are shared with members after the session.

Nov 16, 2026

workshop

Event

Job Hunt and Career

Getting an AI engineering job takes more than learning the tools. You need a project worth showing, a CV that matches the role, and a way to stand out in a crowded market. In this session we recap the earlier AI Shipping Labs career workshops (portfolio project, CV, personal brand), answer your questions about careers in AI engineering and review a few members' CVs and projects live. No code this time. What we'll cover: - How to pick a portfolio project from real companies and real job descriptions, not from a technology you want to try - How to tailor your CV for AI engineering roles and for a specific opening - How to make your work visible so people find you - Live review of a few members' CVs and projects - Your questions: switching into AI engineering, interviews, take-home assignments, what companies actually look for You'll leave with a clear plan for your next steps in the job search. Who it's for: engineers, data scientists and developers who want to move into AI engineering roles or are actively looking. Prerequisites: none. Bring your current CV, a job description you are interested in, or a project idea if you want feedback. The recording is shared with members after the session. Related workshops: Selecting a portfolio project, Tailor your CV for AI engineering roles, Personal brand for developers.

Nov 10, 2026

workshop

Event

Tracing

When an agent gives a wrong answer, the final output doesn't tell you why. Was it the search, the tool call, the prompt, or the model? Without traces you end up guessing and re-running the agent by hand. In this workshop we take the FAQ agent from our earlier AI Shipping Labs workshops, instrument it with OpenTelemetry and use the traces to understand what it actually did. What we'll cover: - Why logs and the final answer are not enough to debug an agent - Instrument the agent with OpenTelemetry so every LLM call and tool call becomes a span in one trace - Send the traces to Langfuse (open source, can be self-hosted) and read them: inputs, outputs, latency, tokens and cost per step - The same OpenTelemetry traces work with other backends too - Use a trace to find why one specific answer went wrong - Turn interesting traces into examples for evals You'll leave with a working tracing setup you can add to your own agent project. Who it's for: people who already have an agent or RAG app (or followed one of our earlier workshops) and want to see what happens inside it. Prerequisites: Python, an OpenAI (or other LLM provider) API key, a basic agent with tools. The code and recording are shared with members after the session.

Nov 4, 2026

workshop

Event

Building with Jev: Typed Decisions for AI Workflows

Jev is TypeSafe AI's first System One model: it makes fast, typed decisions from application state instead of generating chat text. In this 90-minute hands-on workshop, we will define Choice, Score, and Noul questions, batch independent judgments, and compose probabilities in Python code. We will build a support-ticket router with confidence thresholds, then discuss the native TypeSafe API, OpenRouter access, evaluation, and when a general-purpose LLM remains the better tool. Agenda: - 00:00–00:10 — Jev and the System One mental model - 00:10–00:25 — First typed decision - 00:25–00:40 — Choice, Score, and Noul - 00:40–01:05 — Build a support-ticket router - 01:05–01:18 — Confidence gates and human review - 01:18–01:27 — Native API and OpenRouter - 01:27–01:30 — Wrap-up and Q&A Bring Python and uv. API access is useful for the hands-on portion, but we will also explain the workflow without requiring a live key.

Sep 22, 2026

workshop typesafe jev ai-engineering

Event

Saving Money on API Calls with Batch and Flex Processing

API costs get expensive fast when you run many model calls. In this workshop we'll look at where you can deliberately trade latency for lower cost, especially for evaluations where results usually do not need to be immediate. We'll focus on: - When evaluations can run asynchronously instead of inline - Using OpenAI Batch API for eval runs and other delayed jobs - Using Flex processing for lower-priority Responses / Chat Completions calls - Prompt caching, model choice, and request shaping as cost levers - How to structure an eval pipeline so slower, cheaper calls are acceptable - Failure modes: timeouts, retries, expired batches, and when not to delay Bring an existing eval idea or a workflow with repeated API calls if you want to reason through it live. References: - https://developers.openai.com/api/docs/guides/batch - https://developers.openai.com/api/docs/guides/flex-processing

Jul 2, 2026

workshop openai evaluations cost-optimization

Event

Exploring Vercel: What It Is and How to Deploy

A hands-on session to understand Vercel end to end: what it is, what it gives you, and how to actually ship to it. What we'll explore: - What Vercel is and where it fits (hosting, serverless / edge functions, preview deployments) - Deploying a project from scratch — from git push to a live URL - Environment variables, preview deployments, and custom domains - Serverless and edge functions, and when to reach for each - Gotchas, limits, and pricing to be aware of Bring a Vercel account if you'd like to follow along live. Exploratory, build-alongside format — we figure it out together.

Jun 25, 2026

workshop vercel

Event

Exploring Cloudflare Vectorize and Workers

In the last workshop, Cloudflare Vectorize and Cloudflare Workers came up as one of the items worth a closer look. In this 2-hour hands-on session we figure out how to actually use them together. What we'll explore: - Cloudflare Workers: what they are and how to deploy one - Cloudflare Vectorize: creating a vector index and storing embeddings - Wiring Workers + Vectorize into a small working example (semantic search / RAG) - Limits, gotchas, and when this stack makes sense Bring a Cloudflare account if you'd like to follow along live. This is an exploratory, build-alongside session — we figure it out together.

Jun 17, 2026

workshop cloudflare