Agent Memory & Long-Running Workflows with Python

Give Your Crew a Memory — and the Night Shift

Every agent you’ve built so far wakes up with amnesia. Ask it the same question tomorrow and it starts from zero — no memory of the incident it fixed last night, no idea it already tried that plan and it failed. And it only ever runs when you run it. A real teammate is the opposite: they remember, and they keep working when you’re asleep.

In this course you take opscrew — the multi-agent ops crew you built last time — and turn it into opswatch: a teammate that remembers across runs and works the night shift. It keeps an episodic memory of what actually happened, builds semantic memory it can search (“have we seen this before?”), survives a crash mid-run and resumes where it left off, queues risky fixes for your approval instead of acting alone, and runs unattended on a schedule — leaving a short brief on your desk each morning.

What You’ll Build & Learn

• Why stateless agents forget, and the four kinds of memory — working, episodic, semantic, procedural — and which problem each one solves
• Build a real episodic store in SQLite: record every run as a structured event you can query, replay, and learn from
• Give memory meaning with embeddings — semantic recall as RAG over your own history, so the crew surfaces the past incident that matches the one in front of it
• Consolidate raw episodes into durable notes and forget safely, so memory stays sharp instead of bloating forever
• Make workflows durable: checkpoint each step so a crash, timeout, or restart resumes instead of starting over — with an idempotency guard so nothing runs twice
• Add an asynchronous human-approval queue — the crew proposes, you approve in the morning, and only then does it act
• Run it unattended on a schedule with a systemd timer, under a strict per-run cost budget, and have it write you a morning brief
• Assemble the capstone night-watch and map your hand-rolled durability onto LangGraph to see how the frameworks do it

How You’ll Learn

This is a build-on-your-machine project, not a lecture:

• Build one real system — opswatch — module by module, on top of the crew you already know
• Lock in each concept with a quick quiz
• Download the complete, tested solution project for every step
• Everything runs locally against the free Mistral API and plain SQLite — no GPU, no vector-DB service, no paid tooling

Where This Fits Your Journey

This is the capstone of the BytExplorer AI-Assisted Developer path. It follows Multi-Agent Systems & Orchestration with Python — you take that crew and give it the two things a production teammate can’t live without: memory across runs and durable, scheduled autonomy. It’s the difference between an agent you have to babysit and one that works while you sleep and reports back.

Comfortable with Python and have built (or ready to build) an agent crew? You’re set. By the end you’ll have a memory-backed crew that recalls past incidents, resumes cleanly after a crash, and queues every fix for your morning approval — and the judgment to let it run unattended, safely.

Ready to give your crew a memory and put it on the night shift? Jump in.