A Practical Notebook Collection for Building Agentic AI Systems

You've probably read a dozen explainers on agentic AI by now, and maybe you've even sketched out an architecture or two. But somewhere between the theory and a working implementation, most people get stuck. This repository is a collection of notebooks and code files that walk you through specific, named agent projects—Kimi CLI, OpenSpace, DeepAnalyze-8B, and others—each paired with a written tutorial.

What It Does

The repository is a companion to a series of Marktechpost tutorials on agentic AI. It hosts the working code for each tutorial, mostly as Jupyter notebooks (with a couple of Python files), organized into folders like "Agentic AI Codes," "LLM Projects," "Data Analysis," and "AI Agents Codes." Every entry follows the same pattern: a code link and a tutorial link side by side.

The projects cover a fairly wide spread of the agent space. There's a guide to Google Research's RRSI approach for self-improving agents, a TypeSafe AI Jev walkthrough on typed decisions and speculative fan-out with a System One model, and a build of non-interactive agentic coding workflows using Moonshot AI's Kimi CLI with JSONL streaming and session memory. You'll also find a policy-governed multi-agent financial research workflow built with Omnigent, skill-driven financial analysis agents using Claude and MCP connectors, and a self-evolving agent build on OpenSpace covering skills, MCP, lineage, and low-cost reuse.

The code is notebook-first, so you can read the implementation alongside the explanation rather than piecing it together from a bare script. No install commands or environment setup are provided in the README itself—you'll want the linked tutorial for that context.

Why It's Cool

• It's a curated map, not a dump. The agent space is crowded with half-finished demos. Here, each entry is tied to a specific tutorial, so you know there's an explanation waiting behind the code. That pairing is the whole value proposition.

• The topics are specific enough to actually build from. "Self-evolving agents with skills, MCP, lineage, and low-cost reuse" is a concrete system you can inspect, not a vague capability. Same with "policy-governed multi-agent financial research"—there's a governance model to look at, not just a prompt chain.

• The Kimi CLI notebook is a standout for anyone doing CI-style agent work. Non-interactive coding workflows, JSONL streaming, testing, and session memory are the unglamorous pieces that decide whether an agent survives contact with a real pipeline. Having a worked example of that is genuinely useful.

• There's attention to evaluation, not just building. The EdgeBench entry covers benchmarking, leaderboard analytics, scaling laws, and evaluation metrics. If you've ever shipped an agent and had no idea whether it got better or worse, that's the notebook to start with.

• The DeepAnalyze-8B entry keeps hardware in mind. A T4-friendly autonomous data science agent with sandboxed code execution and iterative analysis—that's a realistic target for people without a rack of A100s.

How to Try It

1. Head to the repository and skim the list to find a project that matches what you're working on.
2. Click the tutorial link for that entry first—it's where the setup context and explanation live, since the README doesn't include install instructions.
3. Open the matching notebook from the Codes link. Most are .ipynb files, so you can run them in Jupyter or Colab; a couple (the Claude financial services and Fable 5 traces entries) are .py files.
4. Work through it end to end, then adapt the pieces you need. The financial workflow and financial analysis agent notebooks are good candidates to fork and modify for your own domain.

If you find the collection useful, the README asks for a star.

Final Thoughts

This isn't a framework or a library—it's a set of tutorials with runnable code attached, and you should treat it that way. The value depends on whether the specific project matches your problem, so browse the list before committing time. For developers who learn by reading working code and then breaking it, though, this is a sensible starting shelf for agent work, especially the entries on non-interactive coding workflows and agent evaluation. If more tutorials get added over time, the collection only gets more useful.