Section 4

Notebooks

The notebooks environment at /notebooks is a Jupyter-style interactive runtime built specifically around the libraries and APIs that matter for agentic AI. Each notebook is a sequence of explanatory tutorial cells written in plain English and runnable code cells written in TypeScript, executed in the browser against the same model gateway that powers the rest of the platform. The environment is designed to be the place you go when you want to understand a single concept deeply, without the overhead of building and configuring a full agent in the Agent Builder.

The two tracks of notebooks

The notebook catalogue is organized into two clearly distinct tracks. The two tracks complement each other and most learners end up moving back and forth between them as their understanding deepens.

LangChain and LangGraph fundamentals is the longer, more structured track. It walks through the entire stack end to end: how prompts and chat models compose, how documents and text splitters work, how to build a retrieval-augmented- generation pipeline from raw documents, how tools and agent loops are wired together, and how LangGraph workflows extend single-agent loops into multi-step, branching computations. By the end of this track you should be comfortable reading and modifying any LangChain or LangGraph codebase you encounter in the wild.
Standalone agents is a collection of bite-sized notebooks that each isolate one specific agent pattern in the smallest amount of code that fully demonstrates it. The current collection includes a Hello-World tool-fetcher that introduces tool calling, a JSON enforcer that demonstrates structured output, a ticket classifier, a mini-RAG, a text-to-SQL agent, a PII sanitiser, a persona translator, a code reviewer, a web summariser, and a self-correction critic loop. Each of these is readable in roughly five minutes and runnable in roughly one.

How notebook cells work

Notebooks behave like a Jupyter kernel that lives in your browser session. Cells run top to bottom, state is preserved between cell executions, and you can edit any cell at any time and re-run only the cells downstream of your change. The execution model is deliberately familiar to anyone who has used a data-science notebook, because that mental model is the right one for experimenting with agents.

Tutorial cells render rich markdown with code snippets, diagrams, and inline links into the rest of the documentation. They are not executable — they exist to teach you what the next code cell is going to do and why it is going to do it. Most notebooks open with three or four tutorial cells before the first runnable cell appears.
Code cells contain TypeScript that can import from the major libraries that matter in this space, including LangChain Core, LangChain Classic, LangGraph, Zod for schema validation, Firecrawl for web fetching, and the platform's own embeddings and chat-completion helpers. The editor has syntax highlighting, autocomplete, and inline error squiggles, and running a cell streams its output back into a panel directly below it.
Shared kernel state means that a variable defined in cell three is available in cell seven, just as you would expect in Jupyter. If you re-run an earlier cell, the variable is redefined; if you delete a cell, the variable persists in memory until you reset the kernel, which you can do at any time from the toolbar.
Output panels show standard output, errors with stack traces, and structured trace information for any model or tool call made from the cell. Because notebook calls go through the same gateway as the rest of the platform, every call also shows up in Analytics with full token, cost, and latency information.

Persistence and forking

The original notebooks shipped by AgentSwarms are read-only templates — you cannot edit the canonical version. The moment you run a cell or modify any text, the runtime automatically creates a personal fork of the notebook attached to your account. Your fork is fully yours: edits persist across sessions, outputs are saved between visits, and you can rename the notebook, duplicate it, or delete it at any time. The canonical template remains untouched so that you always have a clean version to return to if your fork gets confused.

Notebooks are particularly useful when you are learning a single new concept and want to isolate it from the configuration overhead of a full agent. If a concept turns out to be useful in your real work, the natural next step is to encapsulate it as a skill and attach it to one of your agents in the Agent Builder.

Previous3. Real-world templates Next 5. Agent Builder