Agentic AI networks path: 59 days to your own network of agents
Fifty-nine one-hour sessions, one a day, from 3 November to 31 December, in four modules. You start from what a language model computes and end with your own small network of agents running at home: local models, tools, an MCP server, an orchestrator that routes work, a retrieval index, tests, guardrails and measurements, all documented in a public repository.
Who it is for, and where it leads
For anyone comfortable with a terminal and willing to write small Python scripts, learning alone, with free resources and no diploma assumed. The path aims at the practical core of jobs advertised as AI engineer, LLM application developer, AI automation engineer or MLOps/LLMOps technician: integrating models into software, building and testing agents, and running them safely and cheaply. It does not teach how to train models from scratch; that is machine learning research, another path.
What you show a recruiter at the end: one repository, ainet-lab, with four deliverables, one per module.
- Module 1: a machine card: models run, measured speeds, a bench checked by code.
- Module 2: an MCP server with three tools, tested, used by a local model.
- Module 3: a two-agent network with routing and retrieval, with a diagram.
- Module 4: the final project: your home agent network with evaluations, a threat model, cost and speed figures, automation and documentation.
The method, the same every day
| Time | Phase | What you do |
|---|---|---|
| 20 min | Theory | The session's lesson on the module page, answering each exercise before going on. |
| 30 min | Practice | Commands, code and measurements on your own machine, committed to ainet-lab. |
| 10 min | Recap | Three lines in the notebook, then redo the day's exercise without notes. |
The recap is the phase people skip, and it is the one that makes things stick: retrieving from memory is what anchors it.
The tools, installed once (days 1, 8 and 9)
- A computer with 8 GB of RAM at the very least; 16 GB or a graphics card with 8 GB or more makes the path more comfortable. A machine without GPU works with small models.
- llama.cpp and Ollama, two free local runtimes.
- Python with uv, Git, and an editor.
- Docker, from module 4 (for n8n); the site's Docker with GPU access covers the GPU case.
- A notebook: a folder of Markdown files, one per day.
Everything here is free. A hosted model is optional: some sessions compare local and hosted, and several providers have free tiers (see free cloud models behind your gateway). Never put a paid key in a file or a prompt (day 49).
Learning with an AI as a tutor
This path is learnt with an AI next to you, preferably a local model you run yourself from day 8 (your first local model). Use it to be quizzed, to have a notion explained another way, to have your code or prompt reviewed. Three rules:
- Do the work first. Write your script, your answer, your prompt, then ask for review. Never paste its answer as yours: you would learn to copy, not to do.
- Check what it says. A model can be wrong with confidence, especially on versions, flags and dates. Compare with the official documentation linked in each session.
- Ask for questions, not answers. "Quiz me", "what is wrong with this", "explain why" teach more than "do it".
Every session ends its practice with a line With your AI giving a ready-made prompt for the day. Once you have done a task by hand, a note Let an agent do it shows how an agent can take it over and what you still check.
Prompting for agent work
In this job, a prompt is a specification read by a program. A good one has six parts: role and context (who answers, for what situation), task (one checkable outcome), constraints (what is forbidden, the limits), inputs (the real data, pasted, not described), output format (often JSON against a schema) with an example when the format is unusual, and how you will check the answer (by code whenever possible). Each module has a lesson on prompting for its own work: day 10 (anatomy of a prompt), day 15 (system prompts), day 28 (tool descriptions), day 42 (intents for worker agents) and day 50 (security reviews). A model's output is never a verified fact until code or a source has checked it.
The golden rule
One hour every day beats seven hours on Sunday. If you miss a day, do not catch up the next one: shift everything by a day and trim module 4. The dates shown assume a start on 3 November; only the order and the regularity matter.
The four modules
Each module is a page: sessions follow one another, each with its goal, its lesson, step-by-step practice and recap. Tick a module when all its sessions are done; your progress stays in your browser.
Free resources
- Hugging Face — LLM course (module 1)
- Anthropic — interactive prompt engineering tutorial (module 2)
- Model Context Protocol — documentation and Hugging Face MCP course (module 2)
- Hugging Face — AI agents course and Microsoft — AI agents for beginners (module 3)
- Anthropic — Building effective agents (module 3)
- OWASP — Top 10 for LLM applications (module 4)
- n8n — advanced AI documentation (module 4)
- The site's own series: run a 7B model, choosing an agent harness, the deterministic doctrine.
The end-of-path checklist, to tick on 31/12
- I explain tokens, context, KV cache, sampling and quantisation in my own words.
- I run and measure a model with llama.cpp and Ollama, and say which one fits my machine and why.
- I write a six-part prompt and get JSON that validates against a schema.
- I write a tool and an MCP server, and a local model calls them.
- I write an agent loop with a step limit, and route work between a small and a large model.
- I build a retrieval index and measure its recall.
- I test an agent with cases checked by code, and I know the limits of a model as a judge.
- I explain prompt injection and the lethal trifecta, and my agents run with least privilege and no secret in their prompts.
- I know what my agents cost in tokens, time and energy.
- I have a documented home agent network in a public repository.
A box that does not tick is not a failure: it is the list of what you work on first in January.
- 1Agentic AI networks module 1: understand and run a modelDays 1 to 14: what a language model does, tokens, context, sampling, model files and quantisation, running llama.cpp and Ollama, the API, and measuring your own machine.
- 2Agentic AI networks module 2: prompts, structured output, tools and MCPDays 15 to 29: system prompts, examples and reasoning, JSON and schemas, constrained decoding, calling a model from code, tool calling, designing tools, the Model Context Protocol, and your own MCP server.
- 3Agentic AI networks module 3: agents, orchestration, routing, RAG and memoryDays 30 to 44: the agent loop, harnesses, context engineering, workflow patterns, orchestrators and workers, routing between local and hosted models, small judges, embeddings, RAG, memory and agents across machines.
- 4Agentic AI networks module 4: evaluate, secure, measure, automate, shipDays 45 to 59: evaluating and testing agents, prompt injection, least privilege, secrets, security reviews, cost and energy, observability, automation with scripts and n8n, and the final project: your own agent network at home, documented.