Agents Towards Production: The Deployment, Memory, and Observability Layer

Agents Towards Production is Nir Diamant’s other major repo, the one that picks up where his GenAI Agents tutorials end. Twenty-eight production-focused notebooks covering everything you need once your agent actually has users: stateful workflows, vector memory, Docker deployment, FastAPI endpoints, security guardrails, GPU scaling, observability, and evaluation. The unsexy half of agent engineering, taught end-to-end.

View Agents Towards Production on GitHub

The other half of agent engineering

Most agent tutorials stop at “the prototype works on my machine”. This one starts there. The 28 notebooks cover the layer that ships real software: stateful LangGraph workflows, vector memory with Redis and Mem0, real-time web search APIs, Docker containerization, FastAPI service endpoints, security guardrails (prompt injection, jailbreak mitigation), GPU scaling, browser automation, multi-agent coordination, and full observability and evaluation pipelines.

If you’ve ever wondered what separates a hack-day agent from one you’d actually deploy, this repo answers it notebook by notebook.

Sponsored tutorials, and that’s a feature

The repo’s standout structural choice: companies contribute full tutorials for their own tools. LangChain wrote the LangGraph agent tutorial. Redis wrote the agent-memory-with-Redis tutorial. Contextual AI wrote the RAG tutorial. Composio, Browserbase, and others follow the same pattern. Each sponsor-built tutorial is reviewed by Nir before it lands.

This is unusual and worth pausing on. Vendor blog posts are usually marketing; vendor-contributed tutorials in a trusted repo are something else: the vendor has skin in the game because the tutorial has to actually run, and the curator’s reputation sits on top of it. You get the technical depth of vendor documentation without the marketing varnish.

The sibling to GenAI Agents, not a replacement

If you’ve read GenAI Agents, the relationship is simple: that repo teaches agent architecture (reflection, planning, multi-agent patterns, RAG-augmented agents). This one teaches agent delivery (deployment, memory backends, observability, scaling). You need both. Doing this one without that one leaves you with production infrastructure around an agent you don’t understand; doing that one without this one leaves you with a working demo you can’t ship.

The natural sequence is GenAI Agents first to learn the techniques, then this one when you’re ready to put something real in front of users.

What “production-grade” actually means here

It’s not a marketing label. The notebooks include real Dockerfiles, real FastAPI service definitions, real evaluation harnesses with held-out test sets, real observability instrumentation. The error handling is the kind that survives load: timeouts, retries, idempotency. None of this is glamorous, all of it is what’s missing from most agent tutorials.

If you’ve ever tried to ship an agent and discovered your prototype broke the moment traffic arrived, this is the curriculum you wish you’d had first.

Honest gaps and caveats

Two things worth knowing before you dive in. First, “no license declared” means you can read and learn but technically can’t copy-paste the code into a commercial product without asking. Email Nir if you want to use a tutorial as the base for something you ship. Second, the sponsor-driven model means some tutorials are deeper on the sponsor’s tool than on the general technique: the Redis memory tutorial is excellent for Redis specifically, lighter on “how to choose between Redis, Mem0, and Zep”. Pair it with Nir’s separate Agent Memory Techniques repo for the framework comparison.

Get started

Clone and pick a tutorial:

git clone https://github.com/NirDiamant/agents-towards-production.git
cd agents-towards-production/tutorials/LangGraph-agent
cat README.md
docker compose up

Most tutorials ship with a docker-compose.yml: the intended runtime is a container, not a notebook session, which is itself the first production lesson.

Agents Towards Production fills the gap between “working demo” and “deployed system”. If you’re about to ship an agent to real users, do the Docker + FastAPI + observability tutorials in order before you write another line of agent code.